Main Page

<mediawiki xmlns="http://www.mediawiki.org/xml/export-0.10/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.mediawiki.org/xml/export-0.10/ http://www.mediawiki.org/xml/export-0.10.xsd" version="0.10" xml:lang="en">
  <siteinfo>
    <sitename>The Algorithm Design Manual Solution Wiki</sitename>
    <dbname>algorist_users</dbname>
    <base>https://algorist.com//algowiki/index.php/Main_Page</base>
    <generator>MediaWiki 1.34.2</generator>
    <case>first-letter</case>
    <namespaces>
      <namespace key="-2" case="first-letter">Media</namespace>
      <namespace key="-1" case="first-letter">Special</namespace>
      <namespace key="0" case="first-letter" />
      <namespace key="1" case="first-letter">Talk</namespace>
      <namespace key="2" case="first-letter">User</namespace>
      <namespace key="3" case="first-letter">User talk</namespace>
      <namespace key="4" case="first-letter">The Algorithm Design Manual Solution Wiki</namespace>
      <namespace key="5" case="first-letter">The Algorithm Design Manual Solution Wiki talk</namespace>
      <namespace key="6" case="first-letter">File</namespace>
      <namespace key="7" case="first-letter">File talk</namespace>
      <namespace key="8" case="first-letter">MediaWiki</namespace>
      <namespace key="9" case="first-letter">MediaWiki talk</namespace>
      <namespace key="10" case="first-letter">Template</namespace>
      <namespace key="11" case="first-letter">Template talk</namespace>
      <namespace key="12" case="first-letter">Help</namespace>
      <namespace key="13" case="first-letter">Help talk</namespace>
      <namespace key="14" case="first-letter">Category</namespace>
      <namespace key="15" case="first-letter">Category talk</namespace>
      <namespace key="2300" case="first-letter">Gadget</namespace>
      <namespace key="2301" case="first-letter">Gadget talk</namespace>
      <namespace key="2302" case="case-sensitive">Gadget definition</namespace>
      <namespace key="2303" case="case-sensitive">Gadget definition talk</namespace>
    </namespaces>
  </siteinfo>
  <page>
    <title>Main Page</title>
    <ns>0</ns>
    <id>1</id>
    <redirect title="Solution Wiki, The Algorithm Design Manual, 3rd Edition" />
    <revision>
      <id>1</id>
      <timestamp>2020-08-18T01:36:51Z</timestamp>
      <contributor>
        <username>MediaWiki default</username>
        <id>2</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="735">&lt;strong&gt;MediaWiki has been installed.&lt;/strong&gt;

Consult the [https://www.mediawiki.org/wiki/Special:MyLanguage/Help:Contents User's Guide] for information on using the wiki software.

== Getting started ==
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Configuration_settings Configuration settings list]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:FAQ MediaWiki FAQ]
* [https://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation#Translation_resources Localise MediaWiki for your language]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Combating_spam Learn how to combat spam on your wiki]</text>
      <sha1>a5wehuldd0go2uniagwvx66n6c80irq</sha1>
    </revision>
    <revision>
      <id>2</id>
      <parentid>1</parentid>
      <timestamp>2020-08-23T18:36:40Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="585">[[About]]

[[Problem Solutions]]

== Getting started ==
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Configuration_settings Configuration settings list]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:FAQ MediaWiki FAQ]
* [https://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation#Translation_resources Localise MediaWiki for your language]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Combating_spam Learn how to combat spam on your wiki]</text>
      <sha1>12pzvj9jb9lo0koxyuktydzmpr3stlg</sha1>
    </revision>
    <revision>
      <id>11</id>
      <parentid>2</parentid>
      <timestamp>2020-08-23T19:30:36Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="580">[[About]]

[[Chapter List]]

== Getting started ==
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Configuration_settings Configuration settings list]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:FAQ MediaWiki FAQ]
* [https://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation#Translation_resources Localise MediaWiki for your language]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Combating_spam Learn how to combat spam on your wiki]</text>
      <sha1>qdgmbmqfjzidl0e55n8tbbkjbgxigoz</sha1>
    </revision>
    <revision>
      <id>434</id>
      <parentid>11</parentid>
      <timestamp>2020-09-28T17:26:46Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1293">The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with Steven Skiena's The Algorithm Design Manual. Students and other readers are encouraged to contribute hints and answers to all odd numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.

[[Chapter List]]

== Getting started ==
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Configuration_settings Configuration settings list]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:FAQ MediaWiki FAQ]
* [https://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation#Translation_resources Localise MediaWiki for your language]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Combating_spam Learn how to combat spam on your wiki]</text>
      <sha1>t5v2xu80q9t5rao7dzvfbyrqubxyg2n</sha1>
    </revision>
    <revision>
      <id>435</id>
      <parentid>434</parentid>
      <timestamp>2020-09-28T17:27:37Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1320">The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with Steven Skiena's The Algorithm Design Manual. Students and other readers are encouraged to contribute hints and answers to all odd numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.

[[Chapter List]]

== Getting started ==
; Editing
* [http://meta.wikimedia.org/wiki/Help:Formula MediaWiki Help:Formula]
* [http://meta.wikimedia.org/wiki/Help:Wikitext_examples Help:Wikitext Examples]

; Configuration
* [http://www.mediawiki.org/wiki/Manual:Configuration_settings Configuration settings list]

; Mediawiki General
* [http://www.mediawiki.org/wiki/Manual:FAQ MediaWiki FAQ]
* [http://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

; Questions
* [http://www.cs.sunysb.edu/~skiena/ Steven Skiena] (for additional hints and algorithm magic)</text>
      <sha1>koxst2wjy6kkzfmzlgfmh3m7p9m4c4z</sha1>
    </revision>
    <revision>
      <id>436</id>
      <parentid>435</parentid>
      <timestamp>2020-09-28T17:29:58Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1415">The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with the third edition of Steven Skiena's ''The Algorithm Design Manual''. Students and other readers are encouraged to contribute hints and answers to all odd-numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.


[[Chapter List]]

== Getting started ==
; Editing
* [http://meta.wikimedia.org/wiki/Help:Formula MediaWiki Help:Formula]
* [http://meta.wikimedia.org/wiki/Help:Wikitext_examples Help:Wikitext Examples]

; Configuration
* [http://www.mediawiki.org/wiki/Manual:Configuration_settings Configuration settings list]

; Mediawiki General
* [http://www.mediawiki.org/wiki/Manual:FAQ MediaWiki FAQ]
* [http://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

; Questions
*[[User: Algowikiadmin| The Admin]] (editing fixes for the problems)
* [http://www.cs.sunysb.edu/~skiena/ Steven Skiena] (for additional hints and algorithm magic)</text>
      <sha1>qzczuo86hgihjln2mcal8kd1khnjqiz</sha1>
    </revision>
    <revision>
      <id>440</id>
      <parentid>436</parentid>
      <timestamp>2020-09-28T17:54:50Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1480">The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with the third edition of Steven Skiena's ''The Algorithm Design Manual''. Students and other readers are encouraged to contribute hints and answers to all odd-numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.

The chapters and their corresponding exercises can be found [[Chapter List|here]].

== Getting started ==
; Editing
* [http://meta.wikimedia.org/wiki/Help:Formula MediaWiki Help:Formula]
* [http://meta.wikimedia.org/wiki/Help:Wikitext_examples Help:Wikitext Examples]

; Configuration
* [http://www.mediawiki.org/wiki/Manual:Configuration_settings Configuration settings list]

; Mediawiki General
* [http://www.mediawiki.org/wiki/Manual:FAQ MediaWiki FAQ]
* [http://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

; Questions
*[[User: Algowikiadmin| The Admin]] (editing fixes for the problems)
* [http://www.cs.sunysb.edu/~skiena/ Steven Skiena] (for additional hints and algorithm magic)</text>
      <sha1>8heer3ilp0xmzwrueuq0mndvg83l8u5</sha1>
    </revision>
    <revision>
      <id>441</id>
      <parentid>440</parentid>
      <timestamp>2020-09-28T17:55:00Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1481">The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with the third edition of Steven Skiena's ''The Algorithm Design Manual''. Students and other readers are encouraged to contribute hints and answers to all odd-numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.


The chapters and their corresponding exercises can be found [[Chapter List|here]].

== Getting started ==
; Editing
* [http://meta.wikimedia.org/wiki/Help:Formula MediaWiki Help:Formula]
* [http://meta.wikimedia.org/wiki/Help:Wikitext_examples Help:Wikitext Examples]

; Configuration
* [http://www.mediawiki.org/wiki/Manual:Configuration_settings Configuration settings list]

; Mediawiki General
* [http://www.mediawiki.org/wiki/Manual:FAQ MediaWiki FAQ]
* [http://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

; Questions
*[[User: Algowikiadmin| The Admin]] (editing fixes for the problems)
* [http://www.cs.sunysb.edu/~skiena/ Steven Skiena] (for additional hints and algorithm magic)</text>
      <sha1>ompebjpnq5yirrt1d2rn60ns8jnhsrq</sha1>
    </revision>
    <revision>
      <id>442</id>
      <parentid>441</parentid>
      <timestamp>2020-10-01T18:00:51Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1845">The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with the third edition of Steven Skiena's ''The Algorithm Design Manual''. Students and other readers are encouraged to contribute hints and answers to all odd-numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.


==Chapters==

#[[Chapter 1|Introduction to Algorithms]]
#[[Chapter 2|Algorithm Analysis]]
#[[Chapter 3|Data Structures]]
#[[Chapter 4|Sorting]]
#[[Chapter 5|Divide and Conquer]]
#[[Chapter 6|Hashing and Randomized Algorithms]]
#[[Chapter 7|Graph Traversal]]
#[[Chapter 8|Weighted Graph Algorithms]]
#[[Chapter 9|Combinatorial Search]]
#[[Chapter 10|Dynamic Programming]]
#[[Chapter 11|NP-Completeness]]
#[[Chapter 12|Dealing with Hard Problems]]


== Getting started ==
; Editing
* [http://meta.wikimedia.org/wiki/Help:Formula MediaWiki Help:Formula]
* [http://meta.wikimedia.org/wiki/Help:Wikitext_examples Help:Wikitext Examples]

; Configuration
* [http://www.mediawiki.org/wiki/Manual:Configuration_settings Configuration settings list]

; Mediawiki General
* [http://www.mediawiki.org/wiki/Manual:FAQ MediaWiki FAQ]
* [http://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

; Questions
*[[User: Algowikiadmin| The Admin]] (editing fixes for the problems)
* [http://www.cs.sunysb.edu/~skiena/ Steven Skiena] (for additional hints and algorithm magic)</text>
      <sha1>9jk7f64rmrhytrxlugojw7d34evyy15</sha1>
    </revision>
    <revision>
      <id>443</id>
      <parentid>442</parentid>
      <timestamp>2020-10-01T18:01:33Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Chapters */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1851">The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with the third edition of Steven Skiena's ''The Algorithm Design Manual''. Students and other readers are encouraged to contribute hints and answers to all odd-numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.


&lt;big&gt;Chapters&lt;/big&gt;

#[[Chapter 1|Introduction to Algorithms]]
#[[Chapter 2|Algorithm Analysis]]
#[[Chapter 3|Data Structures]]
#[[Chapter 4|Sorting]]
#[[Chapter 5|Divide and Conquer]]
#[[Chapter 6|Hashing and Randomized Algorithms]]
#[[Chapter 7|Graph Traversal]]
#[[Chapter 8|Weighted Graph Algorithms]]
#[[Chapter 9|Combinatorial Search]]
#[[Chapter 10|Dynamic Programming]]
#[[Chapter 11|NP-Completeness]]
#[[Chapter 12|Dealing with Hard Problems]]

== Getting started ==
; Editing
* [http://meta.wikimedia.org/wiki/Help:Formula MediaWiki Help:Formula]
* [http://meta.wikimedia.org/wiki/Help:Wikitext_examples Help:Wikitext Examples]

; Configuration
* [http://www.mediawiki.org/wiki/Manual:Configuration_settings Configuration settings list]

; Mediawiki General
* [http://www.mediawiki.org/wiki/Manual:FAQ MediaWiki FAQ]
* [http://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

; Questions
*[[User: Algowikiadmin| The Admin]] (editing fixes for the problems)
* [http://www.cs.sunysb.edu/~skiena/ Steven Skiena] (for additional hints and algorithm magic)</text>
      <sha1>lss7oogjsfp78ph5f9s5e3nn8c86qkz</sha1>
    </revision>
    <revision>
      <id>444</id>
      <parentid>443</parentid>
      <timestamp>2020-10-01T18:01:44Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1850">The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with the third edition of Steven Skiena's ''The Algorithm Design Manual''. Students and other readers are encouraged to contribute hints and answers to all odd-numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.

&lt;big&gt;Chapters&lt;/big&gt;

#[[Chapter 1|Introduction to Algorithms]]
#[[Chapter 2|Algorithm Analysis]]
#[[Chapter 3|Data Structures]]
#[[Chapter 4|Sorting]]
#[[Chapter 5|Divide and Conquer]]
#[[Chapter 6|Hashing and Randomized Algorithms]]
#[[Chapter 7|Graph Traversal]]
#[[Chapter 8|Weighted Graph Algorithms]]
#[[Chapter 9|Combinatorial Search]]
#[[Chapter 10|Dynamic Programming]]
#[[Chapter 11|NP-Completeness]]
#[[Chapter 12|Dealing with Hard Problems]]

== Getting started ==
; Editing
* [http://meta.wikimedia.org/wiki/Help:Formula MediaWiki Help:Formula]
* [http://meta.wikimedia.org/wiki/Help:Wikitext_examples Help:Wikitext Examples]

; Configuration
* [http://www.mediawiki.org/wiki/Manual:Configuration_settings Configuration settings list]

; Mediawiki General
* [http://www.mediawiki.org/wiki/Manual:FAQ MediaWiki FAQ]
* [http://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

; Questions
*[[User: Algowikiadmin| The Admin]] (editing fixes for the problems)
* [http://www.cs.sunysb.edu/~skiena/ Steven Skiena] (for additional hints and algorithm magic)</text>
      <sha1>4pcbx9ra85jczyudach3pebpsih5cyg</sha1>
    </revision>
    <revision>
      <id>445</id>
      <parentid>444</parentid>
      <timestamp>2020-10-01T18:05:31Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <minor/>
      <comment>Protected "[[Main Page]]" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1850">The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with the third edition of Steven Skiena's ''The Algorithm Design Manual''. Students and other readers are encouraged to contribute hints and answers to all odd-numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.

&lt;big&gt;Chapters&lt;/big&gt;

#[[Chapter 1|Introduction to Algorithms]]
#[[Chapter 2|Algorithm Analysis]]
#[[Chapter 3|Data Structures]]
#[[Chapter 4|Sorting]]
#[[Chapter 5|Divide and Conquer]]
#[[Chapter 6|Hashing and Randomized Algorithms]]
#[[Chapter 7|Graph Traversal]]
#[[Chapter 8|Weighted Graph Algorithms]]
#[[Chapter 9|Combinatorial Search]]
#[[Chapter 10|Dynamic Programming]]
#[[Chapter 11|NP-Completeness]]
#[[Chapter 12|Dealing with Hard Problems]]

== Getting started ==
; Editing
* [http://meta.wikimedia.org/wiki/Help:Formula MediaWiki Help:Formula]
* [http://meta.wikimedia.org/wiki/Help:Wikitext_examples Help:Wikitext Examples]

; Configuration
* [http://www.mediawiki.org/wiki/Manual:Configuration_settings Configuration settings list]

; Mediawiki General
* [http://www.mediawiki.org/wiki/Manual:FAQ MediaWiki FAQ]
* [http://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

; Questions
*[[User: Algowikiadmin| The Admin]] (editing fixes for the problems)
* [http://www.cs.sunysb.edu/~skiena/ Steven Skiena] (for additional hints and algorithm magic)</text>
      <sha1>4pcbx9ra85jczyudach3pebpsih5cyg</sha1>
    </revision>
    <revision>
      <id>460</id>
      <parentid>445</parentid>
      <timestamp>2020-10-26T14:35:55Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Redirected page to [[Solution Wiki, TheAlgorithm Design Manual, 3rd Edition"]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1921">#REDIRECT [[Solution Wiki, TheAlgorithm Design Manual, 3rd Edition"]]

The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with the third edition of Steven Skiena's ''The Algorithm Design Manual''. Students and other readers are encouraged to contribute hints and answers to all odd-numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.

&lt;big&gt;Chapters&lt;/big&gt;

#[[Chapter 1|Introduction to Algorithms]]
#[[Chapter 2|Algorithm Analysis]]
#[[Chapter 3|Data Structures]]
#[[Chapter 4|Sorting]]
#[[Chapter 5|Divide and Conquer]]
#[[Chapter 6|Hashing and Randomized Algorithms]]
#[[Chapter 7|Graph Traversal]]
#[[Chapter 8|Weighted Graph Algorithms]]
#[[Chapter 9|Combinatorial Search]]
#[[Chapter 10|Dynamic Programming]]
#[[Chapter 11|NP-Completeness]]
#[[Chapter 12|Dealing with Hard Problems]]

== Getting started ==
; Editing
* [http://meta.wikimedia.org/wiki/Help:Formula MediaWiki Help:Formula]
* [http://meta.wikimedia.org/wiki/Help:Wikitext_examples Help:Wikitext Examples]

; Configuration
* [http://www.mediawiki.org/wiki/Manual:Configuration_settings Configuration settings list]

; Mediawiki General
* [http://www.mediawiki.org/wiki/Manual:FAQ MediaWiki FAQ]
* [http://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

; Questions
*[[User: Algowikiadmin| The Admin]] (editing fixes for the problems)
* [http://www.cs.sunysb.edu/~skiena/ Steven Skiena] (for additional hints and algorithm magic)</text>
      <sha1>fwa2r0ipcwu9lufl1xvadpk5t77k5th</sha1>
    </revision>
    <revision>
      <id>462</id>
      <parentid>460</parentid>
      <timestamp>2020-10-26T14:37:22Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Changed redirect target from [[Solution Wiki, TheAlgorithm Design Manual, 3rd Edition"]] to [[Solution Wiki, TheAlgorithm Design Manual, 3rd Edition]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1920">#REDIRECT [[Solution Wiki, TheAlgorithm Design Manual, 3rd Edition]]

The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with the third edition of Steven Skiena's ''The Algorithm Design Manual''. Students and other readers are encouraged to contribute hints and answers to all odd-numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.

&lt;big&gt;Chapters&lt;/big&gt;

#[[Chapter 1|Introduction to Algorithms]]
#[[Chapter 2|Algorithm Analysis]]
#[[Chapter 3|Data Structures]]
#[[Chapter 4|Sorting]]
#[[Chapter 5|Divide and Conquer]]
#[[Chapter 6|Hashing and Randomized Algorithms]]
#[[Chapter 7|Graph Traversal]]
#[[Chapter 8|Weighted Graph Algorithms]]
#[[Chapter 9|Combinatorial Search]]
#[[Chapter 10|Dynamic Programming]]
#[[Chapter 11|NP-Completeness]]
#[[Chapter 12|Dealing with Hard Problems]]

== Getting started ==
; Editing
* [http://meta.wikimedia.org/wiki/Help:Formula MediaWiki Help:Formula]
* [http://meta.wikimedia.org/wiki/Help:Wikitext_examples Help:Wikitext Examples]

; Configuration
* [http://www.mediawiki.org/wiki/Manual:Configuration_settings Configuration settings list]

; Mediawiki General
* [http://www.mediawiki.org/wiki/Manual:FAQ MediaWiki FAQ]
* [http://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

; Questions
*[[User: Algowikiadmin| The Admin]] (editing fixes for the problems)
* [http://www.cs.sunysb.edu/~skiena/ Steven Skiena] (for additional hints and algorithm magic)</text>
      <sha1>46i3m0hbc5jaza04ajzjffu1nserf02</sha1>
    </revision>
    <revision>
      <id>464</id>
      <parentid>462</parentid>
      <timestamp>2020-10-28T18:09:06Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Changed redirect target from [[Solution Wiki, TheAlgorithm Design Manual, 3rd Edition]] to [[Solution Wiki, The Algorithm Design Manual, 3rd Edition]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1921">#REDIRECT [[Solution Wiki, The Algorithm Design Manual, 3rd Edition]]

The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with the third edition of Steven Skiena's ''The Algorithm Design Manual''. Students and other readers are encouraged to contribute hints and answers to all odd-numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.

&lt;big&gt;Chapters&lt;/big&gt;

#[[Chapter 1|Introduction to Algorithms]]
#[[Chapter 2|Algorithm Analysis]]
#[[Chapter 3|Data Structures]]
#[[Chapter 4|Sorting]]
#[[Chapter 5|Divide and Conquer]]
#[[Chapter 6|Hashing and Randomized Algorithms]]
#[[Chapter 7|Graph Traversal]]
#[[Chapter 8|Weighted Graph Algorithms]]
#[[Chapter 9|Combinatorial Search]]
#[[Chapter 10|Dynamic Programming]]
#[[Chapter 11|NP-Completeness]]
#[[Chapter 12|Dealing with Hard Problems]]

== Getting started ==
; Editing
* [http://meta.wikimedia.org/wiki/Help:Formula MediaWiki Help:Formula]
* [http://meta.wikimedia.org/wiki/Help:Wikitext_examples Help:Wikitext Examples]

; Configuration
* [http://www.mediawiki.org/wiki/Manual:Configuration_settings Configuration settings list]

; Mediawiki General
* [http://www.mediawiki.org/wiki/Manual:FAQ MediaWiki FAQ]
* [http://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

; Questions
*[[User: Algowikiadmin| The Admin]] (editing fixes for the problems)
* [http://www.cs.sunysb.edu/~skiena/ Steven Skiena] (for additional hints and algorithm magic)</text>
      <sha1>i1i10hg6u2lssax17tngyk7vxyb6ea4</sha1>
    </revision>
  </page>
  <page>
    <title>1.1</title>
    <ns>0</ns>
    <id>16</id>
    <revision>
      <id>37</id>
      <timestamp>2020-08-23T20:35:11Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "''a'' + ''b'' &lt; min(''a,b'') &lt;-&gt; ''a'' &lt; 0 /\ ''b'' &lt; 0  ----  If both ''a'' and ''b'' are negative, ''a'' + ''b''&lt; min(''a, b''). For example        ''a'' = -5       ''b'' =..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="262">''a'' + ''b'' &lt; min(''a,b'') &lt;-&gt; ''a'' &lt; 0 /\ ''b'' &lt; 0

----

If both ''a'' and ''b'' are negative, ''a'' + ''b''&lt; min(''a, b''). For example

      ''a'' = -5
      ''b'' = -7
      ''a'' + ''b'' = -5 + (-7) = -12
      min(-5, -7) = -7


Back to [[Chapter 1]]</text>
      <sha1>6atesk93prj0tduv93lv7x51wh645mn</sha1>
    </revision>
    <revision>
      <id>38</id>
      <parentid>37</parentid>
      <timestamp>2020-08-24T16:15:11Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="294">''a'' + ''b'' &lt; min(''a,b'') &lt;-&gt; ''a'' &lt; 0 /\ ''b'' &lt; 0

(find way to fix math symbols)

----

If both ''a'' and ''b'' are negative, ''a'' + ''b''&lt; min(''a, b''). For example

      ''a'' = -5
      ''b'' = -7
      ''a'' + ''b'' = -5 + (-7) = -12
      min(-5, -7) = -7


Back to [[Chapter 1]]</text>
      <sha1>h9oyu59hstkus6cpuowgpi4gv7j1rzc</sha1>
    </revision>
    <revision>
      <id>44</id>
      <parentid>38</parentid>
      <timestamp>2020-08-31T20:07:11Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="307">&lt;math&gt;a + b &lt; \min(a,b) \Leftrightarrow a &lt; 0 \and b &lt; 0&lt;/math&gt;

----

If both ''a'' and ''b'' are negative, &lt;math&gt;a + b &lt; min(a, b)&lt;/math&gt;. For example

      &lt;math&gt;a = -5&lt;/math&gt;
      &lt;math&gt;b = -7&lt;/math&gt;
      &lt;math&gt;a+ b = -5 + (-7) = -12&lt;/math&gt;
      &lt;math&gt;min(-5, -7) = -7&lt;/math&gt;


Back to [[Chapter 1]]</text>
      <sha1>bh50votvpfeurlvbxmi3yqdk3vy2wsc</sha1>
    </revision>
  </page>
  <page>
    <title>1.11</title>
    <ns>0</ns>
    <id>21</id>
    <revision>
      <id>57</id>
      <timestamp>2020-09-01T12:02:55Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Back to [[Chapter 1]]."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="22">Back to [[Chapter 1]].</text>
      <sha1>6jbwmti6ig5011vt1wtqp36dnt7cv1f</sha1>
    </revision>
  </page>
  <page>
    <title>1.13</title>
    <ns>0</ns>
    <id>27</id>
    <revision>
      <id>66</id>
      <timestamp>2020-09-01T12:18:00Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "The basis case is when &lt;math&gt;n = 0&lt;/math&gt;&lt;br&gt; :&lt;math&gt;\sum_{i=1}^0 i^2 = 0^2 = 0 &lt;/math&gt;&lt;br&gt; and using &lt;math&gt;n=0&lt;/math&gt; in the formula &lt;math&gt;\frac {n(n + 1)(2 \cdot n + 1)} {6}..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1013">The basis case is when &lt;math&gt;n = 0&lt;/math&gt;&lt;br&gt;
:&lt;math&gt;\sum_{i=1}^0 i^2 = 0^2 = 0 &lt;/math&gt;&lt;br&gt;
and using
&lt;math&gt;n=0&lt;/math&gt;
in the formula
&lt;math&gt;\frac {n(n + 1)(2 \cdot n + 1)} {6}&lt;/math&gt;
you get:&lt;br&gt;
:&lt;math&gt;\frac {0(0 + 1)(2 \cdot 0 + 1)} {6} = \frac {0(1)(0 + 1)} {6} = \frac {0} {6} = 0&lt;/math&gt;&lt;br&gt;
Since these are equal, the basis case is true.&lt;br&gt;


Now, I will show that on the assumption that the summation is true for ''n'', it follows that it is true for &lt;math&gt;n+1&lt;/math&gt;

:&lt;math&gt;\sum_{i = 1}^{n + 1} i^2 =
(n + 1)^2 + \sum_{i = 1}^n i^2 =
(n^2 + 2n + 1) + \frac{n(n + 1)(2 \cdot n + 1)} {6} =
\frac{6n^2 + 12n + 6}{6}+ \frac{2n^3 + 3n^2 + n} {6} =
\frac {2n^3 + 9n^2 + 13n + 6} {6}&lt;/math&gt;&lt;br&gt;

Which should be equal to the formula
&lt;math&gt;\frac {n(n + 1)(2 \cdot n + 1)} {6}&lt;/math&gt;
when &lt;math&gt;n = n + 1&lt;/math&gt;:
&lt;math&gt;\frac {(n + 1)(n + 1 + 1)(2 \cdot (n + 1) + 1)} {6}=
\frac {(n + 1)(n + 2)(2n + 2 + 1)} {6}=
\frac {(n^2 + 3n + 2)(2n + 3)} {6}=
\frac {2n^3 + 9n^2 + 13n + 6} {6}&lt;/math&gt;


Back to [[Chapter 1]].</text>
      <sha1>mu48nf03q3z2jupjwyv2o8xqvtfi6jw</sha1>
    </revision>
  </page>
  <page>
    <title>1.15</title>
    <ns>0</ns>
    <id>28</id>
    <revision>
      <id>67</id>
      <timestamp>2020-09-01T12:18:58Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Call the statement &lt;math&gt;S_n&lt;/math&gt; and the general term &lt;math&gt;a_n&lt;/math&gt;&lt;br&gt;  &lt;b&gt;Step 1:&lt;/b&gt; Show that the statement holds for the basis case &lt;math&gt;n = 0&lt;/math&gt;&lt;br&gt;  :&lt;math&gt;a..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1542">Call the statement &lt;math&gt;S_n&lt;/math&gt; and the general term &lt;math&gt;a_n&lt;/math&gt;&lt;br&gt;

&lt;b&gt;Step 1:&lt;/b&gt; Show that the statement holds for the basis case &lt;math&gt;n = 0&lt;/math&gt;&lt;br&gt;

:&lt;math&gt;a_0 = 0 \cdot (0 + 1)(0 + 2) = 0&lt;/math&gt;
&lt;br&gt;&lt;br&gt;
:&lt;math&gt;S_0 = \frac {0 \cdot (0 + 1)(0 + 2)(0 + 3)} {4} = \frac {0} {4} = 0 &lt;/math&gt;&lt;br&gt;

Since &lt;math&gt;a_n = S_n&lt;/math&gt;, the basis case is true.&lt;br&gt;&lt;br&gt;

&lt;b&gt;Step 2:&lt;/b&gt; Assume that &lt;math&gt;n = k&lt;/math&gt; holds.
:&lt;math&gt;S_k = \frac {k(k + 1)(k + 2)(k + 3)} {4}&lt;/math&gt;&lt;br&gt;&lt;br&gt;

&lt;b&gt;Step 3:&lt;/b&gt; Show that on the assumption that the summation is true for ''k'', it follows that it is true for ''k + 1''.

:&lt;math&gt;
\begin{align}
S_{k + 1} &amp; = \sum_{i = 1}^k i(i + 1)(i + 2) + a_{k + 1} \\
          &amp; = \frac{k(k + 1)(k + 2)(k + 3)} {4} + (k + 1)((k + 1) + 1)((k + 1) + 2) \\
          &amp; = \frac{k(k + 1)(k + 2)(k + 3)} {4} + (k + 1)(k + 2)(k + 3) \\ 
          &amp; = \frac{k(k + 1)(k + 2)(k + 3)}{4} + \frac{4 \cdot (k + 1)(k + 2)(k + 3)} {4} \\
\end{align}
&lt;/math&gt;&lt;br&gt;

It's easier to factor than expand. Notice the common factor of ''(k + 1)(k + 2)(k + 3)''.
:&lt;math&gt;S_{k + 1} = \frac{(k + 1)(k + 2)(k + 3)(k + 4)}{4}&lt;/math&gt;&lt;br&gt;

This should be equal to the formula
&lt;math&gt;S_k = \frac{k(k + 1)(k + 2)(k + 3)}{4}&lt;/math&gt;
when ''k = k + 1'':&lt;br&gt;
:&lt;math&gt;\frac{(k + 1)((k + 1) + 1)((k + 2) + 2)((k + 1) + 3)} {4} = 
\frac{(k + 1)(k + 2)(k + 3)(k + 4)} {4}&lt;/math&gt;&lt;br&gt;&lt;br&gt;

Since both the basis and the inductive step have been proved, it has now been proved by mathematical induction that S_n holds for all natural n.

Back to [[Chapter 1]].</text>
      <sha1>lfykcpkia88wuonqc5x9dyekoz4k8tl</sha1>
    </revision>
  </page>
  <page>
    <title>1.17</title>
    <ns>0</ns>
    <id>29</id>
    <revision>
      <id>68</id>
      <timestamp>2020-09-01T12:19:40Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "&lt;b&gt;Step 1:&lt;/b&gt; Show that the statement holds for the basis case &lt;math&gt;n = 1&lt;/math&gt;&lt;br&gt; :&lt;math&gt;\frac {1}{i(i+1)} = \frac {n}{n+1}&lt;/math&gt;&lt;br&gt;&lt;br&gt;  :&lt;math&gt;\frac {1}{1(1+1)} = \fr..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="969">&lt;b&gt;Step 1:&lt;/b&gt; Show that the statement holds for the basis case &lt;math&gt;n = 1&lt;/math&gt;&lt;br&gt;
:&lt;math&gt;\frac {1}{i(i+1)} = \frac {n}{n+1}&lt;/math&gt;&lt;br&gt;&lt;br&gt;

:&lt;math&gt;\frac {1}{1(1+1)} = \frac {1}{1+1}&lt;/math&gt;&lt;br&gt;&lt;br&gt;

:&lt;math&gt;\frac {1}{2} = \frac {1}{2}&lt;/math&gt;&lt;br&gt;&lt;br&gt;

Since &lt;math&gt;1/2 = 1/2&lt;/math&gt;, the basis case is true.&lt;br&gt;&lt;br&gt;

&lt;b&gt;Step 2:&lt;/b&gt; Assume that that summation is true up to ''n''.&lt;br&gt;&lt;br&gt;
&lt;b&gt;Step 3:&lt;/b&gt; Show that on the assumption that the summation is true for ''n'', it follows that it is true for ''n + 1''.

&lt;math&gt;\sum_{i = 1}^{n+1} = \frac{n+1}{n+1+1} = \frac{n}{n+1} + \frac{1}{(n+1)(n+1+1)}&lt;/math&gt;&lt;br&gt;
&lt;math&gt;\frac{n+1}{n+2} = \frac{n(n+2)}{(n+1)(n+2)} + \frac{1}{(n+1)(n+2)}&lt;/math&gt;&lt;br&gt;
&lt;math&gt;\frac{n+1}{n+2} = \frac{n(n+2)+1}{(n+1)(n+2)}&lt;/math&gt;&lt;br&gt;
&lt;math&gt;\frac{n+1}{n+2} = \frac{n^2+2n+1}{(n+1)(n+2)}&lt;/math&gt;&lt;br&gt;
&lt;math&gt;\frac{n+1}{n+2} = \frac{(n+1)(n+1)}{(n+1)(n+2)}&lt;/math&gt;&lt;br&gt;
&lt;math&gt;\frac{n+1}{n+2} = \frac{(n+1)}{(n+2)}&lt;/math&gt;&lt;br&gt;


QED


Back to [[Chapter 1]].</text>
      <sha1>neuu3ez9nyff2as4vuej06vdf7f2bvk</sha1>
    </revision>
  </page>
  <page>
    <title>1.19</title>
    <ns>0</ns>
    <id>30</id>
    <revision>
      <id>69</id>
      <timestamp>2020-09-01T12:20:19Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "&lt;b&gt;Step 1:&lt;/b&gt; Show that the statement holds for the basis case &lt;math&gt;n = 1&lt;/math&gt;&lt;br&gt; :&lt;math&gt;E(n) = n - 1&lt;/math&gt;&lt;br&gt; :&lt;math&gt;E(1) = 1 - 1 = 0&lt;/math&gt;. A tree with one node has..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="651">&lt;b&gt;Step 1:&lt;/b&gt; Show that the statement holds for the basis case &lt;math&gt;n = 1&lt;/math&gt;&lt;br&gt;
:&lt;math&gt;E(n) = n - 1&lt;/math&gt;&lt;br&gt;
:&lt;math&gt;E(1) = 1 - 1 = 0&lt;/math&gt;. A tree with one node has zero edges

&lt;b&gt;Step 2:&lt;/b&gt; Assume that that summation is true up to ''n''.&lt;br&gt;&lt;br&gt;
&lt;b&gt;Step 3:&lt;/b&gt; Show that on the assumption that the summation is true for ''n'', it follows that it is true for ''n + 1''.
:&lt;math&gt;E\left(n + 1\right) = n + 1 - 1&lt;/math&gt;&lt;br&gt;
:&lt;math&gt;\Leftrightarrow E(n) + 1 = n&lt;/math&gt; When adding one node to a tree one edge is added as well&lt;br&gt;
:&lt;math&gt;\Leftrightarrow n -1 + 1 = n&lt;/math&gt;&lt;br&gt;
:&lt;math&gt;\Leftrightarrow n = n&lt;/math&gt;&lt;br&gt;

QED


Back to [[Chapter 1]].</text>
      <sha1>tru3fxu68rc2ja9wp62nz6a5cznlzcq</sha1>
    </revision>
  </page>
  <page>
    <title>1.21</title>
    <ns>0</ns>
    <id>22</id>
    <revision>
      <id>58</id>
      <timestamp>2020-09-01T12:03:35Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Back to [[Chapter 1]]."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="22">Back to [[Chapter 1]].</text>
      <sha1>6jbwmti6ig5011vt1wtqp36dnt7cv1f</sha1>
    </revision>
  </page>
  <page>
    <title>1.23</title>
    <ns>0</ns>
    <id>23</id>
    <revision>
      <id>59</id>
      <timestamp>2020-09-01T12:04:24Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "1 million seconds = 277.777778 hours  1 million seconds = 11.5740741 days  ----   Possible approach:  a) There are 3600s in an hour  b) Eliminating the thousands, we get 1000..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="637">1 million seconds = 277.777778 hours

1 million seconds = 11.5740741 days

----


Possible approach:
 a) There are 3600s in an hour
 b) Eliminating the thousands, we get 1000 / 3.6
 c) 3.6 is about half-way between 3 and 4, thus the result is about 
    (1000/3 + 1000/4)/2 ≈  (333+250) = 583/2 ≈ 290
 d) About 12 days (240 + 48)

Another approach:
 a) There are 3600s in an hour
 b) 3600s goes into 10,000s ≈ 3 hours
 c) multiply 3 with 100 = 300 hours (since 10,000s is 100 times less than 1,000,000)
 d) 24h goes into 30h ≈ 1.2 day
 e) multiply 1.2 by 10 = 12 days (since 30h is 10 times less than 300)

Back to [[Chapter 1]].</text>
      <sha1>e6e9oy1j4gehlql6pizvvf69b8i6gqb</sha1>
    </revision>
  </page>
  <page>
    <title>1.25</title>
    <ns>0</ns>
    <id>24</id>
    <revision>
      <id>60</id>
      <timestamp>2020-09-01T12:06:20Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "I estimate the mouth of the Mississippi at 1 mile wide and 100 feet, or 0.02 miles, deep. If the water were moving at 10 miles an hour, that means that 10 miles x 0.02 miles x..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="481">I estimate the mouth of the Mississippi at 1 mile wide and 100 feet, or 0.02 miles, deep. If the water were moving at 10 miles an hour, that means that 10 miles x 0.02 miles x 1 miles flow through the mouth every hour.

10 x 0.02 x 1 = 0.2, times 24 hours/day = 4.8 cubic miles of water/day.

One assumption is that the tidal currents of the ocean can be neglected because within each 24-hour-period the tide rises and falls twice thus canceling out itself.

Back to [[Chapter 1]].</text>
      <sha1>np4tc0dg4cu6h0s7o21k7tcjij62bba</sha1>
    </revision>
  </page>
  <page>
    <title>1.27</title>
    <ns>0</ns>
    <id>26</id>
    <revision>
      <id>64</id>
      <timestamp>2020-09-01T12:15:13Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Return to [[Chapter 1]]."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">Return to [[Chapter 1]].</text>
      <sha1>p9e7f200fcxhkzzsze9ctzdp1jwaerf</sha1>
    </revision>
  </page>
  <page>
    <title>1.29</title>
    <ns>0</ns>
    <id>25</id>
    <revision>
      <id>61</id>
      <timestamp>2020-09-01T12:07:05Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "1. If there are 10 times as many items, and it is proportional to &lt;math&gt;n^2&lt;/math&gt;, it will take &lt;math&gt;10^2&lt;/math&gt; times as long or 100 seconds. 2. If it proportional to &lt;math..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="313">1. If there are 10 times as many items, and it is proportional to &lt;math&gt;n^2&lt;/math&gt;, it will take &lt;math&gt;10^2&lt;/math&gt; times as long or 100 seconds.
2. If it proportional to &lt;math&gt;nlogn&lt;/math&gt;, it will take &lt;math&gt;(10^4.log_{2} 10^4) / (10^3.log_{2} 10^3)&lt;/math&gt; as long or about 13.33 seconds.

Back to [[Chapter 1]].</text>
      <sha1>jgovxy6av3gq3imyfa3fg7afqcpqczp</sha1>
    </revision>
  </page>
  <page>
    <title>1.3</title>
    <ns>0</ns>
    <id>17</id>
    <revision>
      <id>45</id>
      <timestamp>2020-08-31T20:09:25Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "   a ----------- c ----------- b     \                         /      \--------- d ---------- /  If the distance from ''a'' to ''b'' going through ''d'' is less than the dista..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1611">   a ----------- c ----------- b
    \                         /
     \--------- d ---------- /

If the distance from ''a'' to ''b'' going through ''d'' is less than the distance from ''a'' to ''b'' going through ''c'' but there is a busy traffic intersection at ''d'' with a stop sign that is always backed up, then the route from ''a'' to ''b'' through ''c'' is faster, but the route through ''d'' is shorter.


For example,

&lt;math&gt;dist(a, c) = 10&lt;/math&gt; miles

&lt;math&gt;dist(c, b) = 5&lt;/math&gt; miles

So the distance from ''a'' to ''b'' through ''c'' is 15 miles. Assuming you drive 30 miles per hour, the time to travel this would be 30 minutes


&lt;math&gt;dist(a, d) = 5&lt;/math&gt; miles

&lt;math&gt;dist(c, b) = 5&lt;/math&gt; miles

So the distance from ''a'' to ''b'' through ''d'' is 10 miles. Assuming you drive 30 miles per hour, the time to travel this would be 20 minutes, but due to the busy intersection at ''d'', you are delayed 15 minutes, the total time would be 35 minutes.

---

Another possible solution: You have a longer route with a higher speed and a shorter route with a lower speed. By choosing the numbers appropriately, you can make the longer route be the winner. The speed may be due to law, or due to traffic jam, or because of pot holes on the road :-)

Suppose road of length l1 has speed limit s1 and another road of length l2 has speed limit l2. The shorter route is determined by comparing l1 with l2. The faster route is determined by comparing l1/s1 with l2/s2. With positive numbers, if l1 &gt; l2 but l1 &lt; l2 * s1 / s2, then the faster route differs from the shorter route.


Back to [[Chapter 1]]</text>
      <sha1>im4sbyklns9er10395aim9dknuv4drf</sha1>
    </revision>
  </page>
  <page>
    <title>1.31</title>
    <ns>0</ns>
    <id>31</id>
    <revision>
      <id>70</id>
      <timestamp>2020-09-01T12:21:18Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Back to [[Chapter 1]]."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="22">Back to [[Chapter 1]].</text>
      <sha1>6jbwmti6ig5011vt1wtqp36dnt7cv1f</sha1>
    </revision>
  </page>
  <page>
    <title>1.33</title>
    <ns>0</ns>
    <id>32</id>
    <revision>
      <id>71</id>
      <timestamp>2020-09-01T12:23:23Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with " Answer: Seven races.  '''First 5 races:''' Divide 25 horses into 5 groups and that gives you 5 winners.  '''Sixth race:''' Now race 5 of them that will give you winner and wh..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="7978">
Answer: Seven races.

'''First 5 races:''' Divide 25 horses into 5 groups and that gives you 5 winners.

'''Sixth race:''' Now race 5 of them that will give you winner and which two are the bottom-most group. Reject the bottom two group

Now consider the first 3 groups, G1, G2 and G3

G3 Group (the horse that came 3rd in 6th race) - can only bid for 3rd place so we take him for next level i.e. G31

G2 Group (the horse that came 2nd in 6th race) - can bid for 2&amp; 3rd spots we take top two from this group for next level i.e G21, G22

G1 Group (the horse that came 1st in 6th race) - can bid for 1,2,3rd place, but we have already got our first; so we need only to take 2 from this group  for next level i.e. G11, G12, G13

'''Seventh Race:''': G12, G13, G21, G22, G31  Race them to get 2nd and 3rd winner G11 is already won as 1st winner.


--[[User:Max|Max]] 07:06, 16 June 2010 (EDT)

I get the same answer but want to clarify the notation and solution approach.

Answer: Seven races.

'''First five races:''' First 5 exclusive groups of 5 horses.

'''Sixth race:''' Between all the first-place winners in first five races (leaders). Letter the groups by the order the leaders in the sixth race (e.g. ''a1'' is the fastest of the leaders while ''e1'' is the slowest ''leader'').

Let's list the constraints implied by these results (where ''&gt;&gt;'' means faster).

X(n) &gt;&gt; X(n+1), a1 &gt;&gt; b1, b1 &gt;&gt; c1, c1 &gt;&gt; d1, d1 &gt;&gt; e1 

These constraints allow us to sketch a tree of continuations for the possible ordering:

&lt;pre&gt;
a1
| \   
a2 b1--c1--d1--e1
|  |   |   |   |
a3 b2  c2  d2  e2
&lt;/pre&gt;

Now, we need to devise the next race to give us an answer. Reasoning by constraints and seeking three fastest we can knock out anyone lower than c1 since that would imply that c2 &gt;&gt; b1 &gt;&gt; c1 which is a contradiction.

That leaves us with one more race between a2, a3, b1, b2, c1 to determine the second and third fastest horses.


'''Argument:'''
In the above solution, we are assuming that the winners of each of the groups are better than all the remaining horses in every group. But that might not be true. For example, let us denote the speed (20) of a horse A as A(20). Now let us consider a collection of 9 horses:

Group I
A(10) B(20) C(30) winner: C(30)

Group II
D(40) E(50) F(60) winner: F(60)

Group III
G(70) H(80) I(90) winner: I(90)

We clearly see that if we continue with ONLY the winner of the groups, we get an incorrect answer. We need to pick the top 3 of each group to get the correct answer.


----
--[[User:Luckylovelace|Luckylovelace]] ([[User talk:Luckylovelace|talk]]) 17:52, 19 September 2014 (UTC)

'''Possible solution to proposed argument:'''
I was thinking the same thing as the person who proposed the argument above. However, I think I've reconciled my differences with the first 2 solutions.

I'll explain.

Initially, my solution was to setup the contest (since it is not specified how this can be done) by racing all 5 groups of horses and then only racing the fastest 5 (not necessarily the winner of each group). If the problem is setup in this way then it would only require 6 races. Even better yet you could just race all 5 groups and take the fastest 3 horses, which would only take 5 races. This was my lazyman, practical approach.

After this, I began to think about how you would go about creating a solution if no times were given, meaning you wouldn't know the ordering of the groups. You only know which horse is faster than the other horses in its group. And of course, we'll have to still have at least 5 races so that every horse gets their chance. This will result in 5 groups. So let me clarify my setup of the problem:

The 1st place horse must be faster than 24 other horses
The 2nd place horse must be faster than 23 other horses (all horses except #1)
The 3rd place horse must be faster than 22 other horses (all horses except #2 and #1)

After the first race we know this:


Group A (''X &lt; Y means x is faster than y''):

A1 &lt; A2 &lt; A3 &lt; A4 &lt; A5 (So we know A1 is faster than 4 other horses)

...

Group E:

E1 &lt; E2 &lt; E3 &lt; E4 &lt; E5 (So we know E1 is faster than 4 other horses)

'''So we now have A1, B1, C1, D1, E1 as winners of their group, which are all faster than at least 4 other horses.'''


So now in the 6th race, we determine the first place horse because, we know that they must be faster than all 24 other horses since, they are faster than the fastest horses of all the other groups. To clarify:

(Assuming they placed in lexical order)
A1 &lt; B1 &lt; C1 &lt; D1 &lt; E1 '''=&gt;''' A1 &lt; (B1...B5...C1...C5...D1...D5...E1...E5)

However, we cannot determine 2nd or 3rd place, because other horses in the first group may be faster than horses in 2nd or 3rd place, and other horses in the 2nd group, may be faster than horses in 3rd place.

But, what we do know, is that the horses in 4th and 5th place are slower than all the remaining horses (
B1 &lt; C1 &lt; D1..E5). So we can remove them from the next race.


This opens up 3 new slots (since 1st place has already been determined). Now, as stated previously, we know that 2nd and 3rd could both come from the first group, therefore we must take the next two fastest horses from group 1 (A2, A3). We then know that 3rd place could also come from another horse in the 2nd group, therefore we must take 1 horse from that group (B2).

'''This leaves us with the last and final race between A2, A3, B1, B2, C1.'''


'''Q: Why not take all 3 slots from the first group?'''

This would not make sense since there are only 2 places (2nd and 3rd) left to give. If we did do this, we could potentially be left with this ordering: A1 &lt; B1 &lt; C1 &lt; A2 &lt; A3, which never gives B2 a chance to claim the third place spot should he be faster than C1.

Another way to look at it is as two separate races - one for 2nd, and another for 3rd. In the first race you have A2 and B1 vying for 2nd place, and in the second race, you have A3, B2, and C1 racing for 3rd. Since we are trying to minimize the number of races, we can just combine the two into one race of 5 to determine the final outcome.


I'm guessing this is why it's an interview question. It's vague enough such that there are multiple solutions, which would allow the interviewers to glean a bit of your thought process.


We need '''Seven races'''

1. Divide equally 25 horses into 5 groups: A, B, C, D, E and run 5 races, we will get the following result:
&lt;pre&gt;
A: A1 &gt; A2 &gt; A3 &gt;..
B: B1 &gt; B2 &gt; B3 &gt;..
C: C1 &gt; C2 &gt; C3 &gt;..
D: D1 &gt; D2 &gt; D3 &gt;..
E: E1 &gt; E2 &gt; E3 &gt;..
&lt;/pre&gt;

Other horses were eliminated because they have no chance to belong to TOP 3 fastest horses.

2. Run 6th race with (A1, B1, C1, D1, E1), suppose the result is:
&lt;pre&gt;
A: A1 &gt; A2 &gt; A3 &gt; ..
   V
B: B1 &gt; B2 &gt; B3 &gt; ..
   V
C: C1 &gt; C2 &gt; C3 &gt; ..
   V
D: D1 &gt; D2 &gt; D3 &gt; ..
   V
E: E1 &gt; E2 &gt; E3 &gt; ..
&lt;/pre&gt;
For now, '''A1''' is the fastest horse.

After finding out '''A1''':

- '''D(x)''', '''E(x)''', '''C2''' and '''C3''' can be eliminated because '''[B1, C1]''' is always the better solution.

- '''B3''' can also be eliminated because of '''[B1, B2]'''.

&lt;pre&gt;
A: A2 &gt; A3 
   
B: B1 &gt; B2
   V
C: C1
&lt;/pre&gt;

3. Run 7th race with remaining horses, we will find out the second fastest and third fastest horse.

--[[User:Sandyvu|Sandyvu]] ([[User talk:Sandyvu|talk]]) 11:58, 2 April 2017 (UTC)


Consider the following case, where A is a group name and the numbers are the hypothetical speeds of the horses:
&lt;pre&gt;
A = {91, 92, 93, 94, 95}
B = {81, 82, 83, 84, 85}
C = {71, 72, 73, 74, 75}
D = {61, 62, 63, 64, 65}
E = {51, 52, 53, 54, 55}
&lt;/pre&gt;
In this scenario, we need 8 races to determine first, second and third fastest horses.

-- [[User:Radupopa21]]

Are we over-thinking this? Nothing is stated about presence or absence of stopwatches. Assuming that all races are run over the same distance, run 5 races, with 5 stopwatches timing the 5 competitors. That gives you 25 timings from which you can easily select the top three.

— [[User:Peter]]


Back to [[Chapter 1]].</text>
      <sha1>mu43qpdlbbb5qlf6givp07omuwregch</sha1>
    </revision>
  </page>
  <page>
    <title>1.35</title>
    <ns>0</ns>
    <id>33</id>
    <revision>
      <id>72</id>
      <timestamp>2020-09-01T12:25:02Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "'''Assumptions''': : approx 400000 cars : each car needs to refuel once a week : each gas station is open 10 hours a day and refuels 10 cars an hour : there are enough station..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="806">'''Assumptions''':
: approx 400000 cars
: each car needs to refuel once a week
: each gas station is open 10 hours a day and refuels 10 cars an hour
: there are enough stations to refuel all cars once per week

'''Calculation''':
: cars that can be fueled by 1 station in 1 week
: 10*10*7=700
: a number of gas stations (rounded up):
: ceil(400000/700)=572
----
'''A slightly different approach''':
* approx 300 mln cars in the US (1 car per each citizen).
* each station is open 12hr a day, has 6 places for taking fuel, each fueling takes about 6 min
* amount of cars using given gas station daily: &lt;math&gt;6 * 12 * \frac{60}{6} = 6 * 120 = 720 &lt;/math&gt;
* gas station (at least in Europe) are used always used, so: &lt;math&gt;\frac{300 000 000}{720} \approx  333 000&lt;/math&gt; gas stations.


Back to [[Chapter 1]].</text>
      <sha1>t0nrtsbkmm4eof86tazde8vxsfe2wtm</sha1>
    </revision>
  </page>
  <page>
    <title>1.37</title>
    <ns>0</ns>
    <id>34</id>
    <revision>
      <id>73</id>
      <timestamp>2020-09-01T12:25:44Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "I'm envisioning the United States as a rectangle 1000 miles high and 3000 miles long. I'm not including Alaska, because, although it's large, it doesn't have many roads. Much..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="814">I'm envisioning the United States as a rectangle 1000 miles high and 3000 miles long. I'm not including Alaska, because, although it's large, it doesn't have many roads. Much of the U.S. is rural, so roads are fairly sparse. In the semi-rural area of New York State where I grew up, it was common to go a mile or so without hitting a road. So it's reasonable to imagine the U.S. as a grid of roads, each one mile from the other.

That means that if all roads were evenly distributed, the U.S. would be covered with a grid of 1000 roads of 3000 miles each, and 3000 roads of 1000 miles each, for a total of 6,000,000 miles of roads.

''Editor's Note: Not bad, according to [http://www.nationalatlas.gov/transportation.html National Atlas] there are about 4,000,000 miles of roads in the U.S.

Back to [[Chapter 1]].</text>
      <sha1>l3bzg16mjtpjlliqoezd0bjhffyazkt</sha1>
    </revision>
  </page>
  <page>
    <title>1.5</title>
    <ns>0</ns>
    <id>18</id>
    <revision>
      <id>46</id>
      <timestamp>2020-08-31T20:10:18Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "&lt;p&gt;First-fit algorithm counterexample:&lt;/p&gt; &lt;p&gt; &lt;math&gt;S = \{1, 2, 3\}&lt;/math&gt; &lt;br/&gt; &lt;math&gt;T = 5&lt;/math&gt; &lt;/p&gt;  &lt;p&gt;Best-fit algorithm counterexample:&lt;/p&gt; &lt;p&gt; &lt;math&gt;S = \{1, 2, 3\}&lt;..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1322">&lt;p&gt;First-fit algorithm counterexample:&lt;/p&gt;
&lt;p&gt;
&lt;math&gt;S = \{1, 2, 3\}&lt;/math&gt;
&lt;br/&gt;
&lt;math&gt;T = 5&lt;/math&gt;
&lt;/p&gt;

&lt;p&gt;Best-fit algorithm counterexample:&lt;/p&gt;
&lt;p&gt;
&lt;math&gt;S = \{1, 2, 3\}&lt;/math&gt;
&lt;br/&gt;
&lt;math&gt;T = 5&lt;/math&gt;
&lt;/p&gt;

&lt;p&gt;Largest to smallest algorithm counterexample:&lt;/p&gt;
&lt;p&gt;
&lt;math&gt;S = \{4, 3, 2\}&lt;/math&gt;
&lt;br/&gt;
&lt;math&gt;T = 5&lt;/math&gt;
&lt;/p&gt;
----
&lt;p&gt;Another counterexample:&lt;/p&gt;
If &lt;math&gt;S = \{1, 2, 5, 9, 10\}&lt;/math&gt; and &lt;math&gt;T=11&lt;/math&gt;, the solution would be the subset &lt;math&gt;\{2, 9\}&lt;/math&gt; or &lt;math&gt;\{1, 10\}&lt;/math&gt; which none of the algorithms found.


Using first-fit algorithm (left to right)
{| class="wikitable"
|-
! Item added
! Subset of &lt;math&gt;S&lt;/math&gt;
! Sum
|-
| 1
| &lt;math&gt;\{1\}&lt;/math&gt;
| 1 &lt; 11
|-
| 2
| &lt;math&gt;\{1, 2\}&lt;/math&gt;
| 3 &lt; 11
|-
| 5
| &lt;math&gt;\{1, 2, 5\}&lt;/math&gt;
| 8 &lt; 11
|-
| 9
| &lt;math&gt;\{1, 2, 5, 9\}&lt;/math&gt;
| 17 &gt; 11
|}


Using best-fit algorithm (smallest to largest)
{| class="wikitable"
|-
! Item added
! Subset of &lt;math&gt;S&lt;/math&gt;
! Sum
|-
| 1
| &lt;math&gt;\{1\}&lt;/math&gt;
| 1 &lt; 11
|-
| 2
| &lt;math&gt;\{1, 2\}&lt;/math&gt;
| 3 &lt; 11
|-
| 5
| &lt;math&gt;\{1, 2, 5\}&lt;/math&gt;
| 8 &lt; 11
|-
| 9
| &lt;math&gt;\{1, 2, 5, 9\}&lt;/math&gt;
| 17 &gt; 11
|}


Using largest to smallest
{| class="wikitable"
|-
! Item added
! Subset of &lt;math&gt;S&lt;/math&gt;
! Sum
|-
| 10
| &lt;math&gt;\{10\}&lt;/math&gt;
| 10 &lt; 11
|-
| 9
| &lt;math&gt;\{9, 10\}&lt;/math&gt;
| 19 &gt; 11
|}

Back to [[Chapter 1]]</text>
      <sha1>p89jk13lexty0708apc5fp5n47ieo7l</sha1>
    </revision>
  </page>
  <page>
    <title>1.7</title>
    <ns>0</ns>
    <id>19</id>
    <revision>
      <id>47</id>
      <timestamp>2020-08-31T20:11:55Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Please add proposed solutions to the question here."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="51">Please add proposed solutions to the question here.</text>
      <sha1>0osok6plskhw0dkthg2zetagfyxip19</sha1>
    </revision>
    <revision>
      <id>48</id>
      <parentid>47</parentid>
      <timestamp>2020-08-31T20:12:13Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="74">Please add proposed solutions to the question here.

Back to [[Chapter 1]]</text>
      <sha1>m6n8cx9nzhuswgioeoqrgonl566bdxi</sha1>
    </revision>
  </page>
  <page>
    <title>1.9</title>
    <ns>0</ns>
    <id>20</id>
    <revision>
      <id>55</id>
      <timestamp>2020-09-01T12:01:15Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created blank page</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="0" />
      <sha1>phoiac9h4m842xq45sp7s6u21eteeq1</sha1>
    </revision>
    <revision>
      <id>56</id>
      <parentid>55</parentid>
      <timestamp>2020-09-01T12:01:32Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="22">Back to [[Chapter 1]].</text>
      <sha1>6jbwmti6ig5011vt1wtqp36dnt7cv1f</sha1>
    </revision>
  </page>
  <page>
    <title>10.1</title>
    <ns>0</ns>
    <id>180</id>
    <revision>
      <id>373</id>
      <timestamp>2020-09-21T01:15:49Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 10]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 10]]</text>
      <sha1>l4ttl3xd3qkz3hxc7uq6r7ltand60qd</sha1>
    </revision>
  </page>
  <page>
    <title>10.11</title>
    <ns>0</ns>
    <id>184</id>
    <revision>
      <id>377</id>
      <timestamp>2020-09-21T01:17:56Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Answer to both a) and b) is no. Knapsack problem is NP-complete.  ----   (a) Yes, this is a special case of the Knapsack problem where the value of each item is the same (desc..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="534">Answer to both a) and b) is no. Knapsack problem is NP-complete.

----


(a) Yes, this is a special case of the Knapsack problem where the value of each item is the same (described in section 13.10 of the book).  If we have n programmes with sizes s1 to sn, where si &lt;= sj if i &lt; j, and we can fit the first k on the disk, there can be no larger subset, since in order to fit the (k+1)th item we must remove at least one other item of smaller or equal size.

(a) No.  Let D = 10, and P = { 5, 4, 2, 1, 1, 1 }.


Back to [[Chapter 10]]</text>
      <sha1>6leve6ss96dz6zh3pbhmwzosbtaq83t</sha1>
    </revision>
  </page>
  <page>
    <title>10.13</title>
    <ns>0</ns>
    <id>183</id>
    <revision>
      <id>376</id>
      <timestamp>2020-09-21T01:17:14Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "==== 1 ====  # 20 x 1 # 1 x 6 + 14 x 1  # 2 x 6 + 8 x 1  # 3 x 6 + 2 x 1 # 1 x 10 + 10 x 1 # 1 x 10 + 1 x 6 + 4 x 1 # 2 x 10  ==== 2 ====  More generally:  # there is always o..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="2566">==== 1 ====

# 20 x 1
# 1 x 6 + 14 x 1 
# 2 x 6 + 8 x 1 
# 3 x 6 + 2 x 1
# 1 x 10 + 10 x 1
# 1 x 10 + 1 x 6 + 4 x 1
# 2 x 10

==== 2 ====

More generally:

# there is always one way of making zero from any set of denominations;
# there is one way of making any non-zero sum from one denomination provided that the sum is evenly divisible by the denomination;
# for larger sets of denominations, the number of ways to make a sum S from a set D = { a, b, ... m, n } where Di &lt; Dj for i &lt; j, is the sum of the ways to make S, S - n, ... S - xn from D' = { a, b, c, ... m }.

Implementation in C:

 #include &lt;assert.h&gt;
 #include &lt;stdio.h&gt;
 #include &lt;stdlib.h&gt;
 
 static unsigned
 make_change (unsigned sum, unsigned *coins, size_t nr_coins)
   {
   unsigned **table = malloc (nr_coins * sizeof *table);
 
   assert (table != NULL);
 
   for (size_t c = 0; c &lt; nr_coins; ++c)
     {
     table[c] = malloc ((1 + sum) * sizeof *table[c]);
 
     assert (table[c] != NULL);
 
     if (c == 0)
       {
       /*
        * No. of ways of making s from coins[0]: 1 if s is evenly divisible by
        * coins[0], 0 otherwise.
        */
       for (unsigned s = 0; s &lt;= sum; ++s)
         table[0][s] = s % coins[0] == 0;
       }
     else
       {
       /*
        * One way of making 0 from { coins[0] .. coins[c] }: the empty set.
        */
       table[c][0] = 1;
 
       /*
        * No. of ways of making s from { coins[0] .. coins[c] }: no. of ways of
        * making s - n * coins[c] for n &gt; 0 and s &gt;= n * coins[c]
        * from { coins[0] .. coins[c - 1] }
        */
       for (unsigned s = 1; s &lt;= sum; ++s)
         for (unsigned n = 0; n * coins[c] &lt;= s; n ++)
           table[c][s] += table[c - 1][s - (n * coins[c])];
       }
     }
 
   unsigned rv = table[nr_coins - 1][sum];
 
   for (size_t c = 0; c &lt; nr_coins; ++c)
     free (table[c]);
 
   free (table);
 
   return rv;
   }
 
 static int
 cmp_coins (const void *a, const void *b)
   {
   return (*(unsigned *) a &gt; *(unsigned *) b)
        - (*(unsigned *) a &lt; *(unsigned *) b);
   }
 
 int
 main (int argc, char **argv)
   {
   if (argc &lt; 3)
     exit (EXIT_FAILURE);
 
   unsigned sum = atoi (argv[1]);
 
   size_t nr_coins = argc - 2;
 
   unsigned *coins = malloc (nr_coins * sizeof *coins);
 
   assert (coins != NULL);
 
   for (int i = 2; i &lt; argc; ++i)
     coins[i - 2] = atoi (argv[i]);
 
   qsort (coins, nr_coins, sizeof *coins, cmp_coins);
 
   fprintf (stderr, "%u\n", make_change (sum, coins, nr_coins));

   free (coins);

   exit (EXIT_SUCCESS);
   }


Back to [[Chapter 10]]</text>
      <sha1>lhdpiqtgj35qvgp6vc1n70scmjdz3kp</sha1>
    </revision>
  </page>
  <page>
    <title>10.15</title>
    <ns>0</ns>
    <id>185</id>
    <revision>
      <id>380</id>
      <timestamp>2020-09-21T01:31:11Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 10]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 10]]</text>
      <sha1>l4ttl3xd3qkz3hxc7uq6r7ltand60qd</sha1>
    </revision>
  </page>
  <page>
    <title>10.17</title>
    <ns>0</ns>
    <id>186</id>
    <revision>
      <id>381</id>
      <timestamp>2020-09-21T13:39:36Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 10]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 10]]</text>
      <sha1>l4ttl3xd3qkz3hxc7uq6r7ltand60qd</sha1>
    </revision>
  </page>
  <page>
    <title>10.19</title>
    <ns>0</ns>
    <id>187</id>
    <revision>
      <id>382</id>
      <timestamp>2020-09-21T13:39:44Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 10]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 10]]</text>
      <sha1>l4ttl3xd3qkz3hxc7uq6r7ltand60qd</sha1>
    </revision>
  </page>
  <page>
    <title>10.21</title>
    <ns>0</ns>
    <id>188</id>
    <revision>
      <id>383</id>
      <timestamp>2020-09-21T13:40:05Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 10]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 10]]</text>
      <sha1>l4ttl3xd3qkz3hxc7uq6r7ltand60qd</sha1>
    </revision>
  </page>
  <page>
    <title>10.23</title>
    <ns>0</ns>
    <id>189</id>
    <revision>
      <id>384</id>
      <timestamp>2020-09-21T13:40:18Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 10]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 10]]</text>
      <sha1>l4ttl3xd3qkz3hxc7uq6r7ltand60qd</sha1>
    </revision>
  </page>
  <page>
    <title>10.25</title>
    <ns>0</ns>
    <id>190</id>
    <revision>
      <id>385</id>
      <timestamp>2020-09-21T13:40:34Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 10]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 10]]</text>
      <sha1>l4ttl3xd3qkz3hxc7uq6r7ltand60qd</sha1>
    </revision>
    <revision>
      <id>386</id>
      <parentid>385</parentid>
      <timestamp>2020-09-21T13:41:40Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <minor/>
      <comment>Algowikiadmin moved page [[10.125]] to [[10.25]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 10]]</text>
      <sha1>l4ttl3xd3qkz3hxc7uq6r7ltand60qd</sha1>
    </revision>
  </page>
  <page>
    <title>10.27</title>
    <ns>0</ns>
    <id>192</id>
    <revision>
      <id>389</id>
      <timestamp>2020-09-21T13:44:04Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 10]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 10]]</text>
      <sha1>l4ttl3xd3qkz3hxc7uq6r7ltand60qd</sha1>
    </revision>
  </page>
  <page>
    <title>10.29</title>
    <ns>0</ns>
    <id>193</id>
    <revision>
      <id>390</id>
      <timestamp>2020-09-21T13:44:07Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 10]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 10]]</text>
      <sha1>l4ttl3xd3qkz3hxc7uq6r7ltand60qd</sha1>
    </revision>
  </page>
  <page>
    <title>10.3</title>
    <ns>0</ns>
    <id>178</id>
    <revision>
      <id>371</id>
      <timestamp>2020-09-21T01:15:35Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 10]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 10]]</text>
      <sha1>l4ttl3xd3qkz3hxc7uq6r7ltand60qd</sha1>
    </revision>
  </page>
  <page>
    <title>10.31</title>
    <ns>0</ns>
    <id>194</id>
    <revision>
      <id>391</id>
      <timestamp>2020-09-21T13:44:41Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 10]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 10]]</text>
      <sha1>l4ttl3xd3qkz3hxc7uq6r7ltand60qd</sha1>
    </revision>
  </page>
  <page>
    <title>10.33</title>
    <ns>0</ns>
    <id>195</id>
    <revision>
      <id>392</id>
      <timestamp>2020-09-21T13:44:53Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 10]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 10]]</text>
      <sha1>l4ttl3xd3qkz3hxc7uq6r7ltand60qd</sha1>
    </revision>
  </page>
  <page>
    <title>10.35</title>
    <ns>0</ns>
    <id>196</id>
    <revision>
      <id>393</id>
      <timestamp>2020-09-21T13:44:58Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 10]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 10]]</text>
      <sha1>l4ttl3xd3qkz3hxc7uq6r7ltand60qd</sha1>
    </revision>
  </page>
  <page>
    <title>10.37</title>
    <ns>0</ns>
    <id>197</id>
    <revision>
      <id>395</id>
      <timestamp>2020-09-21T13:48:43Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 10]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 10]]</text>
      <sha1>l4ttl3xd3qkz3hxc7uq6r7ltand60qd</sha1>
    </revision>
  </page>
  <page>
    <title>10.39</title>
    <ns>0</ns>
    <id>199</id>
    <revision>
      <id>397</id>
      <timestamp>2020-09-21T13:49:28Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "== A Python Solution - O(1) == &lt;PRE&gt; import sys n = int(sys.argv[1])  OUT_TMP = "Min # of coins for covering %d: %d, coins used: %s" COINS = tuple(sorted((3, 4, 9, 20, 22, 23)..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="3139">== A Python Solution - O(1) ==
&lt;PRE&gt;
import sys
n = int(sys.argv[1])

OUT_TMP = "Min # of coins for covering %d: %d, coins used: %s"
COINS = tuple(sorted((3, 4, 9, 20, 22, 23), reverse=True))
FAILSAFE_MAX = 9999999999

if len(COINS) &lt; 1: raise Exception("Coins please!")
if len(COINS) == 1:
    c = COINS[0]
    if n % c == 0:
        print OUT_TMP % (n, n/c, [c]*(n/c))
        sys.exit()
    else:
        raise Exception("Impossible!")

CAL_MAX = min(COINS[0] * COINS[1], n+1)

min_coins_n = [0]
min_coins_l = [()]

for i in xrange(1, CAL_MAX):
    if i in COINS:
        min_coins_n.append(1)
        min_coins_l.append((i,))
    else:
        current_min = -1
        for c in COINS:
            smaller_i = i - c
            if smaller_i &gt; 0 and min_coins_n[smaller_i] &lt; FAILSAFE_MAX and \
               (current_min == -1 or min_coins_n[smaller_i] &lt; min_coins_n[current_min]):
                current_min = smaller_i

        if current_min != -1:
            min_coins_n.append(min_coins_n[current_min] + 1)
            l = list(min_coins_l[current_min]) # copy
            l.append(i - current_min)
            # another copy, not required but robuster code
            ll = tuple(l)
            min_coins_l.append(tuple(l))
        else:
            # not changable using the current coins
            min_coins_n.append(FAILSAFE_MAX)
            min_coins_l.append(None)

big_part_n = 0
coins_list = []
remaining_n = n
if n &gt; CAL_MAX:
    n_big_part = n - CAL_MAX
    big_part_n = (n_big_part / COINS[0]) + 1
    coins_list = [COINS[0]] * big_part_n
    remaining_n -= big_part_n * COINS[0]

final_n = big_part_n + min_coins_n[remaining_n]
if final_n &gt;= FAILSAFE_MAX:
    raise Exception("Impossible!")
coins_list.extend(min_coins_l[remaining_n])
print OUT_TMP % (n, final_n, coins_list)
&lt;/PRE&gt;

== A Java solution - O(n) ==

&lt;PRE&gt;

public class CoinProblem {

    public static void main(String[] args) {
        int sumToMakeChangeFor = 20;
        int[] coinDenominations = new int[]{1, 2, 5, 10};

        System.out.println("Number of coins needed = " + numberOfCoinsNeededForChange(sumToMakeChangeFor, coinDenominations));
    }

    private static int numberOfCoinsNeededForChange(int sum, int[] coinDenominations) {
        int[] minimumNumberOfCoinsNeeded = new int[sum + 1];
        for (int i = 0; i &lt;= sum; i++){
            minimumNumberOfCoinsNeeded[i] = Integer.MAX_VALUE;
        }
        minimumNumberOfCoinsNeeded[0] = 0;

        for (int currentSum = 1; currentSum &lt;= sum; currentSum++) {
            for (int j = 0; j &lt; coinDenominations.length; j++) {
                if (coinDenominations[j] &lt;= currentSum &amp;&amp; 
                          ((minimumNumberOfCoinsNeeded[currentSum - coinDenominations[j]] + 1) &lt; minimumNumberOfCoinsNeeded[currentSum]))
                    minimumNumberOfCoinsNeeded[currentSum] = minimumNumberOfCoinsNeeded[currentSum - coinDenominations[j]] + 1;
            }
        }
        return minimumNumberOfCoinsNeeded[sum];
    }
}


&lt;/PRE&gt;

Reference: [http://www.topcoder.com/tc?module=Static&amp;d1=tutorials&amp;d2=dynProg Dynamic Programming, TopCoder.com]


Back to [[Chapter 10]]</text>
      <sha1>iumypzy8ud9qsjxv72ma4e1he8cn3vl</sha1>
    </revision>
  </page>
  <page>
    <title>10.41</title>
    <ns>0</ns>
    <id>198</id>
    <revision>
      <id>396</id>
      <timestamp>2020-09-21T13:49:16Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 10]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 10]]</text>
      <sha1>l4ttl3xd3qkz3hxc7uq6r7ltand60qd</sha1>
    </revision>
  </page>
  <page>
    <title>10.5</title>
    <ns>0</ns>
    <id>179</id>
    <revision>
      <id>372</id>
      <timestamp>2020-09-21T01:15:40Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 10]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 10]]</text>
      <sha1>l4ttl3xd3qkz3hxc7uq6r7ltand60qd</sha1>
    </revision>
  </page>
  <page>
    <title>10.7</title>
    <ns>0</ns>
    <id>181</id>
    <revision>
      <id>374</id>
      <timestamp>2020-09-21T01:16:08Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 10]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 10]]</text>
      <sha1>l4ttl3xd3qkz3hxc7uq6r7ltand60qd</sha1>
    </revision>
  </page>
  <page>
    <title>10.9</title>
    <ns>0</ns>
    <id>182</id>
    <revision>
      <id>375</id>
      <timestamp>2020-09-21T01:16:21Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 10]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 10]]</text>
      <sha1>l4ttl3xd3qkz3hxc7uq6r7ltand60qd</sha1>
    </revision>
  </page>
  <page>
    <title>11.1</title>
    <ns>0</ns>
    <id>74</id>
    <revision>
      <id>181</id>
      <timestamp>2020-09-10T21:34:03Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 12]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 12]]</text>
      <sha1>6iwupbb0spsbqxvksre5p6qx8suokj7</sha1>
    </revision>
    <revision>
      <id>182</id>
      <parentid>181</parentid>
      <timestamp>2020-09-10T21:34:19Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 11]]</text>
      <sha1>qwvo7qguqtmvynzyl4vf5rfu4tk1iv6</sha1>
    </revision>
  </page>
  <page>
    <title>11.11</title>
    <ns>0</ns>
    <id>79</id>
    <revision>
      <id>188</id>
      <timestamp>2020-09-10T21:45:19Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 11]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 11]]</text>
      <sha1>qwvo7qguqtmvynzyl4vf5rfu4tk1iv6</sha1>
    </revision>
  </page>
  <page>
    <title>11.13</title>
    <ns>0</ns>
    <id>83</id>
    <revision>
      <id>196</id>
      <timestamp>2020-09-11T19:18:55Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 11]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 11]]</text>
      <sha1>qwvo7qguqtmvynzyl4vf5rfu4tk1iv6</sha1>
    </revision>
  </page>
  <page>
    <title>11.15</title>
    <ns>0</ns>
    <id>80</id>
    <revision>
      <id>193</id>
      <timestamp>2020-09-11T19:16:53Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 11]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 11]]</text>
      <sha1>qwvo7qguqtmvynzyl4vf5rfu4tk1iv6</sha1>
    </revision>
  </page>
  <page>
    <title>11.17</title>
    <ns>0</ns>
    <id>81</id>
    <revision>
      <id>194</id>
      <timestamp>2020-09-11T19:18:04Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 11]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 11]]</text>
      <sha1>qwvo7qguqtmvynzyl4vf5rfu4tk1iv6</sha1>
    </revision>
  </page>
  <page>
    <title>11.19</title>
    <ns>0</ns>
    <id>82</id>
    <revision>
      <id>195</id>
      <timestamp>2020-09-11T19:18:31Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 11]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 11]]</text>
      <sha1>qwvo7qguqtmvynzyl4vf5rfu4tk1iv6</sha1>
    </revision>
  </page>
  <page>
    <title>11.21</title>
    <ns>0</ns>
    <id>84</id>
    <revision>
      <id>197</id>
      <timestamp>2020-09-11T19:21:09Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 11]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 11]]</text>
      <sha1>qwvo7qguqtmvynzyl4vf5rfu4tk1iv6</sha1>
    </revision>
  </page>
  <page>
    <title>11.23</title>
    <ns>0</ns>
    <id>85</id>
    <revision>
      <id>198</id>
      <timestamp>2020-09-11T19:22:32Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 11]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 11]]</text>
      <sha1>qwvo7qguqtmvynzyl4vf5rfu4tk1iv6</sha1>
    </revision>
  </page>
  <page>
    <title>11.25</title>
    <ns>0</ns>
    <id>86</id>
    <revision>
      <id>199</id>
      <timestamp>2020-09-11T19:23:53Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 11]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 11]]</text>
      <sha1>qwvo7qguqtmvynzyl4vf5rfu4tk1iv6</sha1>
    </revision>
  </page>
  <page>
    <title>11.27</title>
    <ns>0</ns>
    <id>87</id>
    <revision>
      <id>200</id>
      <timestamp>2020-09-11T22:06:11Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 11]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 11]]</text>
      <sha1>qwvo7qguqtmvynzyl4vf5rfu4tk1iv6</sha1>
    </revision>
  </page>
  <page>
    <title>11.29</title>
    <ns>0</ns>
    <id>88</id>
    <revision>
      <id>201</id>
      <timestamp>2020-09-11T22:06:30Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 11]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 11]]</text>
      <sha1>qwvo7qguqtmvynzyl4vf5rfu4tk1iv6</sha1>
    </revision>
  </page>
  <page>
    <title>11.3</title>
    <ns>0</ns>
    <id>75</id>
    <revision>
      <id>183</id>
      <timestamp>2020-09-10T21:34:39Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 11]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 11]]</text>
      <sha1>qwvo7qguqtmvynzyl4vf5rfu4tk1iv6</sha1>
    </revision>
  </page>
  <page>
    <title>11.31</title>
    <ns>0</ns>
    <id>89</id>
    <revision>
      <id>202</id>
      <timestamp>2020-09-11T22:06:55Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 11]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 11]]</text>
      <sha1>qwvo7qguqtmvynzyl4vf5rfu4tk1iv6</sha1>
    </revision>
  </page>
  <page>
    <title>11.33</title>
    <ns>0</ns>
    <id>90</id>
    <revision>
      <id>203</id>
      <timestamp>2020-09-11T22:07:35Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 11]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 11]]</text>
      <sha1>qwvo7qguqtmvynzyl4vf5rfu4tk1iv6</sha1>
    </revision>
  </page>
  <page>
    <title>11.35</title>
    <ns>0</ns>
    <id>91</id>
    <revision>
      <id>205</id>
      <timestamp>2020-09-11T22:09:27Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 11]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 11]]</text>
      <sha1>qwvo7qguqtmvynzyl4vf5rfu4tk1iv6</sha1>
    </revision>
  </page>
  <page>
    <title>11.5</title>
    <ns>0</ns>
    <id>76</id>
    <revision>
      <id>184</id>
      <timestamp>2020-09-10T21:35:04Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 11]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 11]]</text>
      <sha1>qwvo7qguqtmvynzyl4vf5rfu4tk1iv6</sha1>
    </revision>
  </page>
  <page>
    <title>11.7</title>
    <ns>0</ns>
    <id>77</id>
    <revision>
      <id>185</id>
      <timestamp>2020-09-10T21:35:32Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 11]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 11]]</text>
      <sha1>qwvo7qguqtmvynzyl4vf5rfu4tk1iv6</sha1>
    </revision>
  </page>
  <page>
    <title>11.9</title>
    <ns>0</ns>
    <id>78</id>
    <revision>
      <id>186</id>
      <timestamp>2020-09-10T21:35:41Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 11]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 11]]</text>
      <sha1>qwvo7qguqtmvynzyl4vf5rfu4tk1iv6</sha1>
    </revision>
  </page>
  <page>
    <title>12.1</title>
    <ns>0</ns>
    <id>63</id>
    <revision>
      <id>167</id>
      <timestamp>2020-09-10T21:08:23Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 12]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 12]]</text>
      <sha1>6iwupbb0spsbqxvksre5p6qx8suokj7</sha1>
    </revision>
  </page>
  <page>
    <title>12.11</title>
    <ns>0</ns>
    <id>68</id>
    <revision>
      <id>172</id>
      <timestamp>2020-09-10T21:09:41Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 12]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 12]]</text>
      <sha1>6iwupbb0spsbqxvksre5p6qx8suokj7</sha1>
    </revision>
  </page>
  <page>
    <title>12.13</title>
    <ns>0</ns>
    <id>69</id>
    <revision>
      <id>174</id>
      <timestamp>2020-09-10T21:10:53Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 12]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 12]]</text>
      <sha1>6iwupbb0spsbqxvksre5p6qx8suokj7</sha1>
    </revision>
  </page>
  <page>
    <title>12.15</title>
    <ns>0</ns>
    <id>70</id>
    <revision>
      <id>175</id>
      <timestamp>2020-09-10T21:11:03Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 12]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 12]]</text>
      <sha1>6iwupbb0spsbqxvksre5p6qx8suokj7</sha1>
    </revision>
  </page>
  <page>
    <title>12.17</title>
    <ns>0</ns>
    <id>71</id>
    <revision>
      <id>176</id>
      <timestamp>2020-09-10T21:11:13Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 12]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 12]]</text>
      <sha1>6iwupbb0spsbqxvksre5p6qx8suokj7</sha1>
    </revision>
  </page>
  <page>
    <title>12.19</title>
    <ns>0</ns>
    <id>73</id>
    <revision>
      <id>178</id>
      <timestamp>2020-09-10T21:11:34Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 12]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 12]]</text>
      <sha1>6iwupbb0spsbqxvksre5p6qx8suokj7</sha1>
    </revision>
  </page>
  <page>
    <title>12.21</title>
    <ns>0</ns>
    <id>72</id>
    <revision>
      <id>177</id>
      <timestamp>2020-09-10T21:11:24Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 12]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 12]]</text>
      <sha1>6iwupbb0spsbqxvksre5p6qx8suokj7</sha1>
    </revision>
  </page>
  <page>
    <title>12.3</title>
    <ns>0</ns>
    <id>64</id>
    <revision>
      <id>168</id>
      <timestamp>2020-09-10T21:08:35Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 12]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 12]]</text>
      <sha1>6iwupbb0spsbqxvksre5p6qx8suokj7</sha1>
    </revision>
  </page>
  <page>
    <title>12.5</title>
    <ns>0</ns>
    <id>65</id>
    <revision>
      <id>169</id>
      <timestamp>2020-09-10T21:08:56Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 12]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 12]]</text>
      <sha1>6iwupbb0spsbqxvksre5p6qx8suokj7</sha1>
    </revision>
  </page>
  <page>
    <title>12.7</title>
    <ns>0</ns>
    <id>66</id>
    <revision>
      <id>170</id>
      <timestamp>2020-09-10T21:09:15Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 12]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 12]]</text>
      <sha1>6iwupbb0spsbqxvksre5p6qx8suokj7</sha1>
    </revision>
  </page>
  <page>
    <title>12.9</title>
    <ns>0</ns>
    <id>67</id>
    <revision>
      <id>171</id>
      <timestamp>2020-09-10T21:09:29Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 12]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">

Back to [[Chapter 12]]</text>
      <sha1>6iwupbb0spsbqxvksre5p6qx8suokj7</sha1>
    </revision>
  </page>
  <page>
    <title>2.1</title>
    <ns>0</ns>
    <id>35</id>
    <revision>
      <id>123</id>
      <timestamp>2020-09-08T19:25:40Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with " This loop can be expressed as the sum:  &lt;math&gt; \sum_{i=1}^{n-1}\sum_{j=i+1}^{n}\sum_{k=1}^{j}1 &lt;/math&gt;  Reducing this, sum by sum from the rhs:  &lt;math&gt; \begin{align} &amp;\sum_{i..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="3063">
This loop can be expressed as the sum:

&lt;math&gt;
\sum_{i=1}^{n-1}\sum_{j=i+1}^{n}\sum_{k=1}^{j}1
&lt;/math&gt;

Reducing this, sum by sum from the rhs:

&lt;math&gt;
\begin{align}
&amp;\sum_{i=1}^{n-1}\sum_{j=i+1}^{n}\sum_{k=1}^{j}1 =\\
&amp;\sum_{i=1}^{n-1}\sum_{j=i+1}^{n}j =\\
&amp;\sum_{i=1}^{n-1}\left(\sum_{j=1}^{n}j - \sum_{j=1}^{i}j\right) =\\
&amp;\sum_{i=1}^{n-1}\left(\frac{n(n+1)}{2} - \frac{i(i+1)}{2}\right) =\\
&amp;\frac{1}{2}\sum_{i=1}^{n-1}n^2+n-i^2-i =\\
&amp;\frac{1}{2}\left((n-1)n^2 + (n-1)n - \left(\frac{n(n+1)(2n+1)}{6} - n^2\right) - 
    \left(\frac{n(n+1)}{2} - n\right)\right) =\\
&amp;f(n) = \frac{n(n(n+1))}{2} - \frac{n(n+1)(2n+1)}{12} - \frac{n(n+1)}{4}
\end{align}
&lt;/math&gt;

n=1 gives zero;
and order is O((n^3)/3)


== Alternative Derivation ==

&lt;math&gt;
\begin{align}
&amp;mystery(n)=\sum_{i=1}^{n-1}\sum_{j=i+1}^{n}\sum_{k=1}^{j} 1\\
&amp;=\sum_{i=1}^{n-1}\sum_{j=i+1}^{n}j\\
\end{align}
&lt;/math&gt;

Taking the following well-known formula for the sum of the integers &lt;math&gt;1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt;:-

&lt;math&gt;
\sum_{x=1}^{n}x = \frac{1}{2}n(n + 1)
&lt;/math&gt;

And noting that:-

&lt;math&gt;
\sum_{j=i+1}^{n}j = \sum_{j=1}^{n}j - \sum_{j=1}^{i}j 
&lt;/math&gt;

We continue our derivation thus:-

&lt;math&gt;
\begin{align}
&amp;=\sum_{i=1}^{n-1}(\frac{1}{2}n(n+1) - \frac{1}{2}i(i+1))\\
&amp;=\frac{1}{2}n(n-1)(n+1) - \frac{1}{2}\sum_{i=1}^{n-1}(i^2 + i)\\
\end{align}
&lt;/math&gt;

Given our formula for the sum of integers, substituting &lt;math&gt;n-1&lt;/math&gt; for &lt;math&gt;n&lt;/math&gt; gives us:-

&lt;math&gt;
\sum_{x=1}^{n-1}x=\frac{1}{2}(n-1)((n-1)+1)=\frac{1}{2}n(n-1)
&lt;/math&gt;

Thus continuing with our derivation:-

&lt;math&gt;
\begin{align}
&amp;=\frac{1}{2}n(n-1)(n+1)- \frac{1}{2}\frac{1}{2}n(n-1) - \frac{1}{2}\sum_{i=1}^{n-1}i^2\\
&amp;=\frac{1}{2}n(n-1)(n + 1 - \frac{1}{2}) - \frac{1}{2}\sum_{i=1}^{n-1}i^2\\
&amp;=\frac{1}{2}n(n-1)(n + \frac{1}{2}) - \frac{1}{2}\sum_{i=1}^{n-1}i^2\\
\end{align}
&lt;/math&gt;

Let us consider the well-known formula for the sum of the squares of the integers between &lt;math&gt;1&lt;/math&gt; and &lt;math&gt;n&lt;/math&gt;:-

&lt;math&gt;
\sum_{x=1}^{n}x^2=\frac{1}{6}n(n+1)(2n+1)
&lt;/math&gt;

As before, let us substitute &lt;math&gt;n-1&lt;/math&gt; for &lt;math&gt;n&lt;/math&gt;:-

&lt;math&gt;
\sum_{x=1}^{n-1}x^2=\frac{1}{6}(n-1)((n-1)+1)(2(n-1)+1)=\frac{1}{6}n(n-1)(2n-1)
&lt;/math&gt;

Substituting this into our derivation gives us:-

&lt;math&gt;
\begin{align}
&amp;=\frac{1}{2}n(n-1)(n + \frac{1}{2}) - \frac{1}{2}\frac{1}{6}n(n-1)(2n - 1)\\
&amp;=\frac{1}{2}n(n-1)(n + \frac{1}{2} - \frac{1}{6}(2n-1))\\
&amp;=\frac{1}{2}n(n-1)(n + \frac{1}{2} - \frac{1}{3}n + \frac{1}{6})\\
&amp;=\frac{1}{2}n(n-1)(\frac{2}{3}n + \frac{2}{3})\\
&amp;=\frac{1}{3}n(n-1)(n+1)
\end{align}
&lt;/math&gt;

Thus the solution is &lt;math&gt;mystery(n)=\frac{1}{3}n(n-1)(n+1)&lt;/math&gt;. This is the equivalent to the solution given by the previous derivation.

The Big-Oh complexity of this function (ignoring constants) is O(n^3), as the RAM model dictates that each iteration of the increment of &lt;math&gt;r&lt;/math&gt; is a time-step. We can ignore the first and last line's contribution to running time for the purposes of Big-Oh, as they do not contribute to the growth of the time taken with input size.


Return to [[Chapter 2]]</text>
      <sha1>bw0txst1xg2w9y4oo2urpk3hvelz3l0</sha1>
    </revision>
  </page>
  <page>
    <title>2.11</title>
    <ns>0</ns>
    <id>40</id>
    <revision>
      <id>134</id>
      <timestamp>2020-09-10T19:38:27Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 2]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 2]]</text>
      <sha1>5ys5ep0s6y9x6zuxmru1g47mbm4h8mo</sha1>
    </revision>
  </page>
  <page>
    <title>2.13</title>
    <ns>0</ns>
    <id>41</id>
    <revision>
      <id>135</id>
      <timestamp>2020-09-10T19:39:20Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "because  &lt;math&gt; n^2 &lt;= 2^n &lt;/math&gt; for every n greater than 4 . Hence, we can say that &lt;math&gt; n^2 &lt; = C* 2^n &lt;/math&gt; for every n&gt;=4 and so &lt;math&gt; n^2 = O(2^n)&lt;/math&gt;.   Back t..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="190">because 
&lt;math&gt; n^2 &lt;= 2^n &lt;/math&gt; for every n greater than 4 .
Hence, we can say that &lt;math&gt; n^2 &lt; = C* 2^n &lt;/math&gt; for every n&gt;=4 and so &lt;math&gt; n^2 = O(2^n)&lt;/math&gt;.


Back to [[Chapter 2]]</text>
      <sha1>kfjvaj27d1ktjehkrihwav9el3qz862</sha1>
    </revision>
  </page>
  <page>
    <title>2.15</title>
    <ns>0</ns>
    <id>42</id>
    <revision>
      <id>136</id>
      <timestamp>2020-09-10T19:40:21Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 2]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 2]]</text>
      <sha1>5ys5ep0s6y9x6zuxmru1g47mbm4h8mo</sha1>
    </revision>
  </page>
  <page>
    <title>2.17</title>
    <ns>0</ns>
    <id>43</id>
    <revision>
      <id>137</id>
      <timestamp>2020-09-10T19:41:00Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 2]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 2]]</text>
      <sha1>5ys5ep0s6y9x6zuxmru1g47mbm4h8mo</sha1>
    </revision>
  </page>
  <page>
    <title>2.19</title>
    <ns>0</ns>
    <id>61</id>
    <revision>
      <id>158</id>
      <timestamp>2020-09-10T20:00:49Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 2]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 2]]</text>
      <sha1>5ys5ep0s6y9x6zuxmru1g47mbm4h8mo</sha1>
    </revision>
  </page>
  <page>
    <title>2.21</title>
    <ns>0</ns>
    <id>62</id>
    <revision>
      <id>159</id>
      <timestamp>2020-09-10T20:01:20Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 2]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 2]]</text>
      <sha1>5ys5ep0s6y9x6zuxmru1g47mbm4h8mo</sha1>
    </revision>
  </page>
  <page>
    <title>2.23</title>
    <ns>0</ns>
    <id>59</id>
    <revision>
      <id>156</id>
      <timestamp>2020-09-10T19:59:51Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 2]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 2]]</text>
      <sha1>5ys5ep0s6y9x6zuxmru1g47mbm4h8mo</sha1>
    </revision>
  </page>
  <page>
    <title>2.25</title>
    <ns>0</ns>
    <id>60</id>
    <revision>
      <id>157</id>
      <timestamp>2020-09-10T20:00:19Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 2]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 2]]</text>
      <sha1>5ys5ep0s6y9x6zuxmru1g47mbm4h8mo</sha1>
    </revision>
  </page>
  <page>
    <title>2.27</title>
    <ns>0</ns>
    <id>58</id>
    <revision>
      <id>155</id>
      <timestamp>2020-09-10T19:59:20Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 2]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 2]]</text>
      <sha1>5ys5ep0s6y9x6zuxmru1g47mbm4h8mo</sha1>
    </revision>
  </page>
  <page>
    <title>2.29</title>
    <ns>0</ns>
    <id>57</id>
    <revision>
      <id>154</id>
      <timestamp>2020-09-10T19:58:30Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 2]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 2]]</text>
      <sha1>5ys5ep0s6y9x6zuxmru1g47mbm4h8mo</sha1>
    </revision>
  </page>
  <page>
    <title>2.3</title>
    <ns>0</ns>
    <id>36</id>
    <revision>
      <id>124</id>
      <timestamp>2020-09-09T18:49:32Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "&lt;math&gt;f(n) = (((n^2)(n+1)^2)/8) + n(n+1)(2n+1)/12&lt;/math&gt; ---- This problem does appear to break down into a series of nested summations:  &lt;math&gt; \displaystyle\sum_{i=1}^{n}\te..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1620">&lt;math&gt;f(n) = (((n^2)(n+1)^2)/8) + n(n+1)(2n+1)/12&lt;/math&gt;
----
This problem does appear to break down into a series of nested summations:

&lt;math&gt;
\displaystyle\sum_{i=1}^{n}\text{ }
\displaystyle\sum_{j=1}^{i}\text{ }
\displaystyle\sum_{k=j}^{i+j}\text{ }
\displaystyle\sum_{l=1}^{j+i-k}1
&lt;/math&gt;

In the last summation, the formula is independent of the iterator, which translates into adding the value 1, &lt;math&gt;j+i-k&lt;/math&gt; times:

&lt;math&gt;
\displaystyle\sum_{i=1}^{n}
\displaystyle\sum_{j=1}^{i}
\displaystyle\sum_{k=j}^{i+j}(j+i-k)
&lt;/math&gt;

Now the third summation goes from &lt;math&gt;j&lt;/math&gt; to &lt;math&gt;i+j&lt;/math&gt; the formula on closer examination reveals that 

&lt;math&gt;\displaystyle\sum_{k=j}^{i+j}(j+i-k)&lt;/math&gt; is &lt;math&gt; \displaystyle\sum_{k=1}^{i}(k) &lt;/math&gt; which is equal to &lt;math&gt;i*(i+1)/2&lt;/math&gt;

Since &lt;math&gt;\displaystyle\sum_{k=start}^{end}(end-k) = \displaystyle\sum_{k=1}^{end-start}(k) &lt;/math&gt;

So the summation boils down to

&lt;math&gt;
\displaystyle\sum_{i=1}^{n}
\displaystyle\sum_{j=1}^{i} (i*(i+1)/2)
&lt;/math&gt;

The formula in the second summation is independent of the iterator, which translates to adding &lt;math&gt;i*(i+1)/2&lt;/math&gt;, &lt;math&gt;i&lt;/math&gt; times.

&lt;math&gt;
\displaystyle\sum_{i=1}^{n}(i^2 * (i+1)/2)
&lt;/math&gt;

which is

&lt;math&gt;
\displaystyle\sum_{i=1}^{n}((i^3 + i^2)/2)
&lt;/math&gt;


&lt;math&gt;\frac{1}{2} \left(\Sigma r^3 + \Sigma r^2\right) = 
\frac{1}{2}\left(\frac{n^2\left(n+1\right)^2}{4} + 
\frac {n \left(n+1\right)\left(2n+1\right)}{6}\right) = 
\frac{n^2\left(n+1\right)^2}{8} + \frac {n \left(n+1\right)\left(2n+1\right)}{12}&lt;/math&gt;


Time Complexity = O&lt;math&gt;({n}^{4})&lt;/math&gt;


----

Back to [[Chapter 2]]</text>
      <sha1>j7l0zglyt9zszgpqyfp636hbmxajmwd</sha1>
    </revision>
  </page>
  <page>
    <title>2.31</title>
    <ns>0</ns>
    <id>56</id>
    <revision>
      <id>153</id>
      <timestamp>2020-09-10T19:57:55Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 2]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 2]]</text>
      <sha1>5ys5ep0s6y9x6zuxmru1g47mbm4h8mo</sha1>
    </revision>
  </page>
  <page>
    <title>2.33</title>
    <ns>0</ns>
    <id>55</id>
    <revision>
      <id>152</id>
      <timestamp>2020-09-10T19:57:19Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 2]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 2]]</text>
      <sha1>5ys5ep0s6y9x6zuxmru1g47mbm4h8mo</sha1>
    </revision>
  </page>
  <page>
    <title>2.35</title>
    <ns>0</ns>
    <id>54</id>
    <revision>
      <id>151</id>
      <timestamp>2020-09-10T19:56:23Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 2]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 2]]</text>
      <sha1>5ys5ep0s6y9x6zuxmru1g47mbm4h8mo</sha1>
    </revision>
  </page>
  <page>
    <title>2.37</title>
    <ns>0</ns>
    <id>53</id>
    <revision>
      <id>149</id>
      <timestamp>2020-09-10T19:55:26Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "On careful observation , one can see that the sum of any row is just  &lt;math&gt;3^{n-1}&lt;/math&gt; this is the sum for the series . This can even be computed using a series as shown b..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="701">On careful observation , one can see that the sum of any row is just  &lt;math&gt;3^{n-1}&lt;/math&gt;
this is the sum for the series . This can even be computed using a series as shown below 

 1=a0
 1 1 1 
 a1 a0 a2

now a(mid) of the next line becomes the a(0) +a(1) +a(2)  that it this mid element is always the sum of the middle three elements


'''Alternate explanation :'''

Every element in the current row will be used 3 times in next row; once directly below it, and also in left and right element below it.

So sum of elements in &lt;math&gt;(n+1)&lt;/math&gt;th row will be 3*(sum of elements in &lt;math&gt;n&lt;/math&gt;th row).

Hence, S(n) = &lt;math&gt;3^{n-1}&lt;/math&gt; (Base case : For 1st row, sum is 1)

Back to [[Chapter 2]]</text>
      <sha1>tv1vhm5nndkopx08hincnl0bincab9k</sha1>
    </revision>
    <revision>
      <id>150</id>
      <parentid>149</parentid>
      <timestamp>2020-09-10T19:55:44Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="704">On careful observation, one can see that the sum of any row is just  &lt;math&gt;3^{n-1}&lt;/math&gt;
this is the sum for the series. This can even be computed using a series as shown below 

 1=a0
 1 1 1 
 a1 a0 a2

now a(mid) of the next line becomes the a(0) +a(1) +a(2)  that it this mid element is always the sum of the middle three elements


'''Alternate explanation :'''

Every element in the current row will be used 3 times in the next row; once directly below it, and also in left and right element below it.

So sum of elements in &lt;math&gt;(n+1)&lt;/math&gt;th row will be 3*(sum of elements in &lt;math&gt;n&lt;/math&gt;th row).

Hence, S(n) = &lt;math&gt;3^{n-1}&lt;/math&gt; (Base case : For 1st row, sum is 1)


Back to [[Chapter 2]]</text>
      <sha1>78xdu61mgm1yuxe4zr2liktw1amn59i</sha1>
    </revision>
  </page>
  <page>
    <title>2.39</title>
    <ns>0</ns>
    <id>52</id>
    <revision>
      <id>148</id>
      <timestamp>2020-09-10T19:54:45Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 2]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 2]]</text>
      <sha1>5ys5ep0s6y9x6zuxmru1g47mbm4h8mo</sha1>
    </revision>
  </page>
  <page>
    <title>2.41</title>
    <ns>0</ns>
    <id>51</id>
    <revision>
      <id>147</id>
      <timestamp>2020-09-10T19:53:47Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 2]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 2]]</text>
      <sha1>5ys5ep0s6y9x6zuxmru1g47mbm4h8mo</sha1>
    </revision>
  </page>
  <page>
    <title>2.43</title>
    <ns>0</ns>
    <id>50</id>
    <revision>
      <id>146</id>
      <timestamp>2020-09-10T19:51:57Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "X=n-digit number (abcdefghijklmn), y= n-digit number (ABCDEFGHIJKLMN) say  X * y = X * N + X * M0 + X * L00 + X * K000 + .... + X * B000000000000 + X * A0000000000000  With ea..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="472">X=n-digit number (abcdefghijklmn), y= n-digit number (ABCDEFGHIJKLMN) say

X * y = X * N + X * M0 + X * L00 + X * K000 + .... + X * B000000000000 + X * A0000000000000

With each multiple consisting of further digit by digit multiplications as

X * N = n * N + m0 * M + l00 * L + k000 * K + .... + b000000000000 * B + a0000000000000 * A

i.e.  n multiples, each generated with n digit by digit multiplications and additions hence, &lt;math&gt;O(n^2)&lt;/math&gt;

Back to [[Chapter 2]]</text>
      <sha1>8cz5hsyyipr8z0b218q1bj0shbfcijj</sha1>
    </revision>
  </page>
  <page>
    <title>2.45</title>
    <ns>0</ns>
    <id>49</id>
    <revision>
      <id>145</id>
      <timestamp>2020-09-10T19:51:00Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 2]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 2]]</text>
      <sha1>5ys5ep0s6y9x6zuxmru1g47mbm4h8mo</sha1>
    </revision>
  </page>
  <page>
    <title>2.47</title>
    <ns>0</ns>
    <id>48</id>
    <revision>
      <id>142</id>
      <timestamp>2020-09-10T19:45:40Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Change the assumptions of the proof.  The paper mentioned is "S. Skiena. Encroaching lists as a measure of presortedness. BIT, 28:775-784, 1988."   '''Other solution :'''   &lt;m..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="523">Change the assumptions of the proof.

The paper mentioned is "S. Skiena. Encroaching lists as a measure of presortedness. BIT, 28:775-784, 1988."


'''Other solution :''' 

&lt;math&gt; O(nlog(√n)) &lt;/math&gt; and &lt;math&gt; O(nlog(n)) &lt;/math&gt; belongs to same class of function with respect to Big O notation.
There is no difference between them other than a constant factor.


&lt;math&gt;\lim_{x\to\infty} (nlog(√n)) / (nlog(n))&lt;/math&gt; 
= &lt;math&gt;\lim_{x\to\infty} 1/2*(nlog(n))/(nlog(n)) &lt;/math&gt;
= &lt;math&gt;1/2&lt;/math&gt;


Back to [[Chapter 2]]</text>
      <sha1>hgth43bqa0pj1m4arkig3biqyqx76lz</sha1>
    </revision>
    <revision>
      <id>143</id>
      <parentid>142</parentid>
      <timestamp>2020-09-10T19:49:09Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="527">Change the assumptions of the proof.

The paper mentioned is "S. Skiena. Encroaching lists as a measure of presortedness. BIT, 28:775-784, 1988."


'''Other solution :''' 

&lt;math&gt; O(nlog(\sqrtn)) &lt;/math&gt; and &lt;math&gt; O(nlog(n)) &lt;/math&gt; belongs to same class of function with respect to Big O notation.
There is no difference between them other than a constant factor.


&lt;math&gt;\lim_{x\to\infty} (blog(/sqrtn)) / (nlog(n))&lt;/math&gt; 
= &lt;math&gt;\lim_{x\to\infty} 1/2*(nlog(n))/(nlog(n)) &lt;/math&gt;
= &lt;math&gt;1/2&lt;/math&gt;


Back to [[Chapter 2]]</text>
      <sha1>3fczaumysoz7fffdz2n7samqp3gmsje</sha1>
    </revision>
    <revision>
      <id>144</id>
      <parentid>143</parentid>
      <timestamp>2020-09-10T19:50:16Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="531">Change the assumptions of the proof.

The paper mentioned is "S. Skiena. Encroaching lists as a measure of presortedness. BIT, 28:775-784, 1988."


'''Other solution :''' 

&lt;math&gt; O(nlog(\sqrt{n})) &lt;/math&gt; and &lt;math&gt; O(nlog(n)) &lt;/math&gt; belongs to same class of function with respect to Big O notation.
There is no difference between them other than a constant factor.


&lt;math&gt;\lim_{x\to\infty} (nlog(\sqrt{n})) / (nlog(n))&lt;/math&gt; 
= &lt;math&gt;\lim_{x\to\infty} 1/2*(nlog(n))/(nlog(n)) &lt;/math&gt;
= &lt;math&gt;1/2&lt;/math&gt;


Back to [[Chapter 2]]</text>
      <sha1>3mrebksgv348uhb9s4g3cnmteytr52z</sha1>
    </revision>
  </page>
  <page>
    <title>2.49</title>
    <ns>0</ns>
    <id>47</id>
    <revision>
      <id>141</id>
      <timestamp>2020-09-10T19:44:46Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 2]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 2]]</text>
      <sha1>5ys5ep0s6y9x6zuxmru1g47mbm4h8mo</sha1>
    </revision>
  </page>
  <page>
    <title>2.5</title>
    <ns>0</ns>
    <id>37</id>
    <revision>
      <id>125</id>
      <timestamp>2020-09-09T18:50:52Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "   Back to [[Chapter 2]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24">


Back to [[Chapter 2]]</text>
      <sha1>smj7iwycrrs7lk3wn8wytur0fp0y53c</sha1>
    </revision>
  </page>
  <page>
    <title>2.51</title>
    <ns>0</ns>
    <id>46</id>
    <revision>
      <id>140</id>
      <timestamp>2020-09-10T19:43:59Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "&lt;pre&gt; 1) Find an empty bag (labeled "E") 2) Place 1 coin from bag 1 into E 3) Place 2 coins from bag 2 into E ... 10) Place 9 coins from bag 9 into E 11) Place 10 coins from b..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="519">&lt;pre&gt;
1) Find an empty bag (labeled "E")
2) Place 1 coin from bag 1 into E
3) Place 2 coins from bag 2 into E
...
10) Place 9 coins from bag 9 into E
11) Place 10 coins from bag 10 into E
12) Weigh bag E on your digital scale
&lt;/pre&gt;

If all coins were 10 grams, the bag would weigh 550 grams.  Thus, &lt;math&gt;550 - weight&lt;/math&gt; will tell you how many coins are too light.  Since this number of coins correlates to the bag from which the coins came, you now know which bag contains the light coins.


Back to [[Chapter 2]]</text>
      <sha1>1sq9oetc1q6ienykvr93ce8dgt0ucy0</sha1>
    </revision>
  </page>
  <page>
    <title>2.53</title>
    <ns>0</ns>
    <id>45</id>
    <revision>
      <id>139</id>
      <timestamp>2020-09-10T19:43:00Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Some incorrect answers were reached. These have been moved to the discussion, with explanation of where the argument goes wrong.  The correct answer: Assuming pairwise merges..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="3485">Some incorrect answers were reached. These have been moved to the discussion, with explanation of where the argument goes wrong.

The correct answer: Assuming pairwise merges (no k-way merges) we have &lt;math&gt;n-1&lt;/math&gt; merge stages where each set of companies is generated from the previous stage (the merged pair being one company). If we characterize each complete merge as different if two companies merge at different stages then we are looking at combinations. In the first stage we have &lt;math&gt;\binom{n}{2}&lt;/math&gt; ways to choose a merge pair and a new set for the next stage. Thus, we have the Cartesian product of each stage set and we can calculate the size as:

&lt;math&gt;\prod_{i=2}^{n} \frac{i(i-1)}{2} = \frac{n! (n-1)!}{2^{n-1}}&lt;/math&gt;

Proof by induction follows easily as long as we agree with the counting process for first non-trivial basis (i.e. &lt;math&gt;n=3&lt;/math&gt; where our formula indicates there are three different possible merges):

&lt;pre&gt;
{a,b,c} -&gt; {ab, c} -&gt; {abc}
        -&gt; {a, bc} -&gt; {abc}
        -&gt; {ac, b} -&gt; {abc}
&lt;/pre&gt;

And, since we have three paths we can say that's three merges -- this counts a merge step as the same if it results in the same set of companies going on to the next stage. But, instead if we count the actual merge operations:

&lt;pre&gt;
{a, b, c} -&gt; {a+b, c}, {(a+b) + c}, {a, b+c}, {a + (b+c)},
             {a+c, b}, {(a+c) + b}
&lt;/pre&gt;

then we need to change the denominator in our previous formula:

&lt;math&gt;2^{n-1} \rightarrow 2^{n-2}&lt;/math&gt; to get six steps.

__________________________________________________________________________________

Solution above is correct given its assumptions but this problem can be more interesting.   According to the examples above, {a, b, c, d} -&gt; {ab, c, d} -&gt; {ab, cd} is different from  {a, b, c, d} -&gt; {a, b, cd} -&gt; {ab, cd}.  I would argue that the two paths are the same.  I would define two path to be the same if each employee of each company sees their own company merging sequentially with the same companies in both paths.  In the example above, the employees of company c see that they merged with d and then with ab in both paths to full merger.  Think about this.  It is kinda complicated.  So if we write down an individual merge sequence for each of the companies, then two paths are equal if all of their individual merge sequences are equal.  Now how to calculate the number of paths? 

Pick company number N and assume it's IBM.  Now consider IBM's individual merging path.  It could be {IBM} -&gt; {IBM, DELL}, or {IBM} -&gt; {IBM, DELL, Apple} or {IBM} -&gt; {IBM, Google, Netflix, Amazon}.  The aspect I'm emphasizing here is that in its first merger, IBM could merge with 1 to n-1 many companies.  We can compute all of the paths by adding up these scenarios.  So let's say IBM will be merging with i companies in its first merger.  How many paths would we have now.  Let's define f(n) to be the number of merger paths for n companies (the number we are trying to find). Then there are &lt;math&gt; {n-1 \choose i} &lt;/math&gt; ways to pick the i companies IBM will be merging with.  Those companies have to merge only with each other before they merge with IBM and there are f(i) ways to do that.  After IBM has merge with the i companies, then we have n-i companies left to merge (counting the big set of i companies as one company), and there are f(n-i) ways to do that.  So we get the recursive equation: &lt;math&gt; f(n) = \sum^{n-1}_{i=1} f(i)f(n-i){n-1 \choose i} &lt;/math&gt;.


Back to [[Chapter 2]]</text>
      <sha1>35nbvyyg6w8x7wpkewefw3oezqbsevr</sha1>
    </revision>
  </page>
  <page>
    <title>2.55</title>
    <ns>0</ns>
    <id>44</id>
    <revision>
      <id>138</id>
      <timestamp>2020-09-10T19:41:59Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "This problem is a famous game-theoretical scenario called the pirate game (http://en.wikipedia.org/wiki/Pirate_game). Assume the senior pirate gets to vote.  Where there is on..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="2899">This problem is a famous game-theoretical scenario called the pirate game (http://en.wikipedia.org/wiki/Pirate_game). Assume the senior pirate gets to vote.

Where there is only 1 indivisible dollar:
2 pirates - The senior pirate gets it.
3+ pirates - The least senior pirate gets it.

In general, every 2 + 2^K (k &gt;= 1) pirate will survive, while the others will die

'''Another Answer''' :
Assume senior pirate also gets to vote.

Based on pirates inherent tendency -

'''a.''' They want to kill other pirates even if it does not affect their outcome - 

2 pirates:  Senior gets it.

3 pirates: Least-senior pirate gets it because the 2nd-least-senior pirate will vote for kill; so in order to live, he/she must give the gold to the least-senior pirate.

4 pirates: 2nd or 3rd-least-senior pirate will get gold (equally likely) because 1st will vote for kill irrespective of whether he/she gets the gold or not, and the 2nd or 3rd-least-senior pirate will vote for the plan if he/she 
gets the gold respectively.

5 pirates - This pirate is certainly going to die regardless of his/her proposal since there will be at least 3 pirates that don't get the gold and thus vote to kill him/her. This will eventually lead to the above situation where the 2nd or 3rd-least-senior pirate will receive the gold.

6 pirates: The 5th-least-senior pirate will vote for whatever plan the most senior pirate proposes—if the proposal falls down to him/her, then he/she is guaranteed to die as explained above. In order to get the last vote, the most senior pirate can give the gold to any of the remaining four pirates. The reason for each is below—recall, the desire to have the gold surpasses the desire to kill another pirate (e.g., if Pirate A has a 50% chance of getting the gold without killing anyone vs. a 49% chance of getting the gold and killing everyone else, he/she will choose the former):

• 4th-least-senior pirate: would agree to receive the coin, because as mentioned before, if the 5th-least-senior pirate decides, he/she will die. This will eventually result in this pirate having to give away the coin in order to live as described in the "4 pirates" situation.

• 3rd-least-senior pirate: would agree to receive the coin since there would only be a 50% chance he/she would get it as described in the eventually inevitable "4 pirates" situation.

• 2nd-least-senior pirate: same reasoning as above.

• Least senior pirate: the least senior pirate would agree to receive the coin since he/she would have a 0% chance to receive the gold as described in the eventually inevitable "4 pirates" situation.

Thus the result would be that no one dies and either the first, second, third, or fourth-least-senior pirate would receive the coin.

'''b.''' They want as many other pirates to live if it doesn't affect their outcome - 

Senior most pirate gets the gold.


Back to [[Chapter 2]]</text>
      <sha1>5jpt4namrds2rgh05vjxi4ydfl907es</sha1>
    </revision>
  </page>
  <page>
    <title>2.7</title>
    <ns>0</ns>
    <id>38</id>
    <revision>
      <id>126</id>
      <timestamp>2020-09-09T18:51:59Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "'''n = 1'''  The single element array is already its max. Loop is not entered. Max is returned  Let for '''n=k''', the algorithm is true  For '''n = k+1''' ,two cases arise :..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="519">'''n = 1''' 
The single element array is already its max. Loop is not entered. Max is returned

Let for '''n=k''', the algorithm is true

For '''n = k+1''' ,two cases arise :

'''1)''' a[k+1] is max 

'''2)''' a[k+1] is not max.

If '''1)''' holds then at the last iteration when i = k+1, m = a[k+1] is assigned. Hence max is returned

Else if '''2)''' holds then we are left with the task of finding the max among '''n = k''' elements, which we already assumed that the algorithm does correctly.


Back to [[Chater 2]]</text>
      <sha1>61l27ma5c6wboyfvidxw1hzteq8shud</sha1>
    </revision>
    <revision>
      <id>127</id>
      <parentid>126</parentid>
      <timestamp>2020-09-09T18:52:16Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="520">'''n = 1''' 
The single element array is already its max. Loop is not entered. Max is returned

Let for '''n=k''', the algorithm is true

For '''n = k+1''' ,two cases arise :

'''1)''' a[k+1] is max 

'''2)''' a[k+1] is not max.

If '''1)''' holds then at the last iteration when i = k+1, m = a[k+1] is assigned. Hence max is returned

Else if '''2)''' holds then we are left with the task of finding the max among '''n = k''' elements, which we already assumed that the algorithm does correctly.


Back to [[Chapter 2]]</text>
      <sha1>q01y22cwvuat5ayy34o3jemaddj8vs8</sha1>
    </revision>
  </page>
  <page>
    <title>2.9</title>
    <ns>0</ns>
    <id>39</id>
    <revision>
      <id>128</id>
      <timestamp>2020-09-09T18:53:36Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "=2-8.=  For each of the following pairs of functions, either &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Th..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="3175">=2-8.=

For each of the following pairs of functions, either &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.


==&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;==
Answer: &lt;math&gt;\log n^2 = \Theta (\log n + 5)&lt;/math&gt;


Solution:

&lt;math&gt;\log n^2 = 2 \times \log n&lt;/math&gt;

&lt;math&gt;2 \times \log n \le 2 \times \log n + 10&lt;/math&gt;

&lt;math&gt;\log n^2 \le 2 (\log n + 5)&lt;/math&gt;

&lt;math&gt;\log n^2 \le C (\log n + 5)&lt;/math&gt; (where &lt;math&gt;C=2&lt;/math&gt;)

&lt;math&gt;\log n^2 = O (\log n + 5)&lt;/math&gt;

Also:

&lt;math&gt;\log n + 5 \le \log n + 5 \log n&lt;/math&gt;

&lt;math&gt;\log n + 5 \le 6 \log n&lt;/math&gt;

&lt;math&gt;\log n + 5 \le 3 \times 2 \log n&lt;/math&gt;

&lt;math&gt;3 \times \log n^2 \ge \log n + 5 &lt;/math&gt;

&lt;math&gt;\log n^2 \ge C \times (\log n + 5)&lt;/math&gt; (Where &lt;math&gt;C =\frac{1}{3}&lt;/math&gt;)

&lt;math&gt;log n^2 = \Omega (\log n + 5)&lt;/math&gt;

And therefore:

&lt;math&gt;log n^2 = \Theta (\log n + 5)&lt;/math&gt;


==&lt;math&gt;f(n)=\sqrt{n}&lt;/math&gt;; &lt;math&gt;g(n)=\log(n^2)&lt;/math&gt;==

Answer: &lt;math&gt;f(n) = \Omega(g(n))&lt;/math&gt;


Solution:

&lt;math&gt;g(n) = \log (n^2) = 2 * \log (n)&lt;/math&gt;

&lt;math&gt;\lim_{n \to \infty} \frac{\sqrt{n}}{2 * log(n)} = 2 * \lim_{n \to \infty} \frac{\sqrt{n}}{log(n)} = \infty&lt;/math&gt;


==&lt;math&gt;f(n)=\log^2(n)&lt;/math&gt;; &lt;math&gt;g(n)=\log (n)&lt;/math&gt;==

Answer: &lt;math&gt;f(n) = \Omega(g(n))&lt;/math&gt;


Solution:

&lt;math&gt;\lim_{n \to \infty} \frac{log^2(n)}{log(n)} = \lim_{n \to \infty} log(n) = \infty&lt;/math&gt;


==&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2(n)&lt;/math&gt;==

Answer: &lt;math&gt;f(n) = \Omega(g(n))&lt;/math&gt;


Solution:

&lt;math&gt;\lim_{n \to \infty} \frac{n}{\log^2(n)} = \lim_{n \to \infty} ((\frac{\sqrt{n}}{\log(n)})^2) = (\lim_{n \to \infty} \frac{\sqrt{n}}{\log(n)})^2 = \infty&lt;/math&gt;


==&lt;math&gt;f(n)=n * \log(n) + n&lt;/math&gt;; &lt;math&gt;g(n)=\log (n)&lt;/math&gt;==

Answer: &lt;math&gt;f(n) = \Omega(g(n))&lt;/math&gt;


Solution:

&lt;math&gt;\lim_{n \to \infty} \frac{n * \log(n) + n}{log(n)} = \lim_{n \to \infty} (\frac{n * \log(n)}{log(n)} + \frac{n}{log(n)}) = \lim_{n \to \infty} (n + \frac{n}{log(n)}) = \infty&lt;/math&gt;


==&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log (10)&lt;/math&gt;==

Answer: &lt;math&gt;f(n) = \Theta(g(n))&lt;/math&gt;


Solution: Both are constants. Constants are always within a constant factor, &lt;math&gt;c&lt;/math&gt;, of each other (as &lt;math&gt;n \rightarrow \infty&lt;/math&gt;).


==&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10n^2&lt;/math&gt;==

Answer: &lt;math&gt;f(n) = \Omega(g(n))&lt;/math&gt;


Solution: 

&lt;math&gt;
\begin{align}
&amp;\lim_{n \to \infty} \frac{2^n}{10n^2} \\
&amp;\implies \frac{1}{10} \left(\lim_{n \to \infty} \frac{2^n}{n^2}\right) \\
&amp;\implies \frac{1}{10} \left(\lim_{n \to \infty} \frac{\ln(2)\cdot 2^n}{2 \cdot n}\right) \text{L'Hopital's Rule} \\
&amp;\implies  \frac{1}{10} \left(\lim_{n \to \infty} \frac{2\ln(2)\cdot 2^n}{2}\right) \text{L'Hopital's Rule} \\
&amp;\implies \frac{\ln(2)}{10} \lim_{n \to \infty} 2^n \\
&amp;\implies \frac{\ln(2)}{10} \lim_{n \to \infty} 2^n = \infty
\end{align}
&lt;/math&gt;

==&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;==

Answer: &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;


Solution: 

&lt;math&gt;\lim_{n \to \infty} \frac{2^n}{3^n} = \lim_{n \to \infty} (\frac{2}{3})^n = 0&lt;/math&gt;


Back to [[Chapter 2]]</text>
      <sha1>2wznvtyrpsgvdjwrsbax8naf3sn26p7</sha1>
    </revision>
    <revision>
      <id>130</id>
      <parentid>128</parentid>
      <timestamp>2020-09-09T19:00:28Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* 2-8. */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="3169">

For each of the following pairs of functions, either &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.


==&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;==
Answer: &lt;math&gt;\log n^2 = \Theta (\log n + 5)&lt;/math&gt;


Solution:

&lt;math&gt;\log n^2 = 2 \times \log n&lt;/math&gt;

&lt;math&gt;2 \times \log n \le 2 \times \log n + 10&lt;/math&gt;

&lt;math&gt;\log n^2 \le 2 (\log n + 5)&lt;/math&gt;

&lt;math&gt;\log n^2 \le C (\log n + 5)&lt;/math&gt; (where &lt;math&gt;C=2&lt;/math&gt;)

&lt;math&gt;\log n^2 = O (\log n + 5)&lt;/math&gt;

Also:

&lt;math&gt;\log n + 5 \le \log n + 5 \log n&lt;/math&gt;

&lt;math&gt;\log n + 5 \le 6 \log n&lt;/math&gt;

&lt;math&gt;\log n + 5 \le 3 \times 2 \log n&lt;/math&gt;

&lt;math&gt;3 \times \log n^2 \ge \log n + 5 &lt;/math&gt;

&lt;math&gt;\log n^2 \ge C \times (\log n + 5)&lt;/math&gt; (Where &lt;math&gt;C =\frac{1}{3}&lt;/math&gt;)

&lt;math&gt;log n^2 = \Omega (\log n + 5)&lt;/math&gt;

And therefore:

&lt;math&gt;log n^2 = \Theta (\log n + 5)&lt;/math&gt;


==&lt;math&gt;f(n)=\sqrt{n}&lt;/math&gt;; &lt;math&gt;g(n)=\log(n^2)&lt;/math&gt;==

Answer: &lt;math&gt;f(n) = \Omega(g(n))&lt;/math&gt;


Solution:

&lt;math&gt;g(n) = \log (n^2) = 2 * \log (n)&lt;/math&gt;

&lt;math&gt;\lim_{n \to \infty} \frac{\sqrt{n}}{2 * log(n)} = 2 * \lim_{n \to \infty} \frac{\sqrt{n}}{log(n)} = \infty&lt;/math&gt;


==&lt;math&gt;f(n)=\log^2(n)&lt;/math&gt;; &lt;math&gt;g(n)=\log (n)&lt;/math&gt;==

Answer: &lt;math&gt;f(n) = \Omega(g(n))&lt;/math&gt;


Solution:

&lt;math&gt;\lim_{n \to \infty} \frac{log^2(n)}{log(n)} = \lim_{n \to \infty} log(n) = \infty&lt;/math&gt;


==&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2(n)&lt;/math&gt;==

Answer: &lt;math&gt;f(n) = \Omega(g(n))&lt;/math&gt;


Solution:

&lt;math&gt;\lim_{n \to \infty} \frac{n}{\log^2(n)} = \lim_{n \to \infty} ((\frac{\sqrt{n}}{\log(n)})^2) = (\lim_{n \to \infty} \frac{\sqrt{n}}{\log(n)})^2 = \infty&lt;/math&gt;


==&lt;math&gt;f(n)=n * \log(n) + n&lt;/math&gt;; &lt;math&gt;g(n)=\log (n)&lt;/math&gt;==

Answer: &lt;math&gt;f(n) = \Omega(g(n))&lt;/math&gt;


Solution:

&lt;math&gt;\lim_{n \to \infty} \frac{n * \log(n) + n}{log(n)} = \lim_{n \to \infty} (\frac{n * \log(n)}{log(n)} + \frac{n}{log(n)}) = \lim_{n \to \infty} (n + \frac{n}{log(n)}) = \infty&lt;/math&gt;


==&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log (10)&lt;/math&gt;==

Answer: &lt;math&gt;f(n) = \Theta(g(n))&lt;/math&gt;


Solution: Both are constants. Constants are always within a constant factor, &lt;math&gt;c&lt;/math&gt;, of each other (as &lt;math&gt;n \rightarrow \infty&lt;/math&gt;).


==&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10n^2&lt;/math&gt;==

Answer: &lt;math&gt;f(n) = \Omega(g(n))&lt;/math&gt;


Solution: 

&lt;math&gt;
\begin{align}
&amp;\lim_{n \to \infty} \frac{2^n}{10n^2} \\
&amp;\implies \frac{1}{10} \left(\lim_{n \to \infty} \frac{2^n}{n^2}\right) \\
&amp;\implies \frac{1}{10} \left(\lim_{n \to \infty} \frac{\ln(2)\cdot 2^n}{2 \cdot n}\right) \text{L'Hopital's Rule} \\
&amp;\implies  \frac{1}{10} \left(\lim_{n \to \infty} \frac{2\ln(2)\cdot 2^n}{2}\right) \text{L'Hopital's Rule} \\
&amp;\implies \frac{\ln(2)}{10} \lim_{n \to \infty} 2^n \\
&amp;\implies \frac{\ln(2)}{10} \lim_{n \to \infty} 2^n = \infty
\end{align}
&lt;/math&gt;

==&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;==

Answer: &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;


Solution: 

&lt;math&gt;\lim_{n \to \infty} \frac{2^n}{3^n} = \lim_{n \to \infty} (\frac{2}{3})^n = 0&lt;/math&gt;


Back to [[Chapter 2]]</text>
      <sha1>7a5089x8k5zrf3dupqjwz8dkxc4nnob</sha1>
    </revision>
  </page>
  <page>
    <title>3.1</title>
    <ns>0</ns>
    <id>92</id>
    <revision>
      <id>278</id>
      <timestamp>2020-09-20T17:56:57Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "You just need to maintain a count, like so:  &lt;pre&gt;     public static boolean isBalanced(String str) {         int count = 0;          for (int i = 0, n = str.length(); i &lt; n;..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="3596">You just need to maintain a count, like so:

&lt;pre&gt;
    public static boolean isBalanced(String str) {
        int count = 0;

        for (int i = 0, n = str.length(); i &lt; n; i++) {
            switch (str.charAt(i)) {
            case '(':
                count++;
                break;
            case ')':
                count--;
                break;
            default:
                throw new IllegalArgumentException();
            }

            if (count &lt; 0) {
                System.out.println("Imbalance at index " + i);
                return false;
            }
        }

        if (count != 0) {
            System.out.println("Imbalance at index " + (str.length() - 1));
            return false;
        }

        return true;
    }
&lt;/pre&gt;

Another Approach to use stack in-order to solve this problem;

   A. Read the string from left to right as CHR
   B. Keep pushing CHR until CHR is not ")"
   1) Pop from stack once CHR == ")"
          if poped element is NOT "("
             return FAlse
    Repeat A
--[[User:Max|Max]] 07:18, 16 June 2010 (EDT)
  
----
The approach below maintains a stack where the index of each opening '(' is pushed onto the stack.  As each closing ')' is found, the index of the matching '(' is popped off the stack.

The string is unbalanced if there:
* is an attempt to pop an element off an empty stack.  The position of the current character can be reported as the position of the first offending parenthesis.
* are any elements left on the stack.  The value of the first element in the stack can be reported as the position of the first offending parenthesis.
&lt;pre&gt;
#include &lt;iostream&gt;
#include &lt;stack&gt;
#include &lt;string&gt;

int main (int argc, char* argv[]) {
  if (argc != 2) {
    std::cout &lt;&lt; "pass a string to check if it's parens are balanced" &lt;&lt; std::endl;
    exit(1);
  }

  std::stack&lt;int&gt; parens;
  std::string input = argv[1];

  for (int i = 0; i &lt; input.length(); i++) {
    char ch = input[i];
    if (ch == ')') {
      if (parens.size() == 0) {
        std::cout &lt;&lt; "unmatched ')' at position: " &lt;&lt; i &lt;&lt; std::endl;
        exit(1);
      }
      parens.pop();
    }
    else if (ch == '(') {
      parens.push(i);
    }
  }
  if (parens.size() != 0) {
    while (parens.size() &gt; 1) {
      parens.pop();
    }
    std::cout &lt;&lt; "unmatched '(' at position: " &lt;&lt; parens.top() &lt;&lt; std::endl;
    exit(1);
  }
  else {
    std::cout &lt;&lt; "parens balanced!" &lt;&lt; std::endl;
  }
}
&lt;/pre&gt;
--[[User:Neonstalwart|Neonstalwart]] ([[User talk:Neonstalwart|talk]]) 22:47, 26 March 2015 (EDT)

----

Max's first example above appears to incorrectly report the last character in the string as the offending index if there is a surplus of opening parentheses.  The following solution (in JavaScript) takes a similar approach, but correctly reports the index of the first unmatched open parenthesis (more like Neonstalwart's solution, but without requiring a stack).

This function returns a number: -1 if balanced, otherwise the index of the first offending parenthesis.

&lt;pre&gt;
function checkParens(str) {
	var numOpen = 0;
	var length = str.length;
	var offender;

	for (var i = 0; i &lt; length; i++) {
		if (str[i] === '(') {
			if (!numOpen) {
				// Store index of first open paren in case it is never closed
				offender = i;
			}
			numOpen++;
		}
		else if (str[i] === ')') {
			if (!numOpen) {
				// Closing paren with none open = instant fail
				return i;
			}
			numOpen--;
		}
	}

	return numOpen === 0 ? -1 : offender;
}
&lt;/pre&gt;
--[[User:CnEY|CnEY]] ([[User talk:CnEY|talk]]) 23:15, 27 August 2015 (EDT)


Back to [[Chapter 3]]</text>
      <sha1>g63mqxkzzhd5ssqcwijggdt30s61hdj</sha1>
    </revision>
  </page>
  <page>
    <title>3.11</title>
    <ns>0</ns>
    <id>97</id>
    <revision>
      <id>284</id>
      <timestamp>2020-09-20T18:02:00Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Since 1,2,...,n is finite, use a bit array to represent them.&lt;br&gt; See the telephone number sorting example in Column 1 of &lt;Programming Pearls&gt; (Jon Bentley) for detailed expla..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="205">Since 1,2,...,n is finite, use a bit array to represent them.&lt;br&gt;
See the telephone number sorting example in Column 1 of &lt;Programming Pearls&gt; (Jon Bentley) for detailed explanation.

Back to [[Chapter 3]]</text>
      <sha1>6cwktn3nz5tnatg34e7bxxp0of9dlr6</sha1>
    </revision>
  </page>
  <page>
    <title>3.13</title>
    <ns>0</ns>
    <id>98</id>
    <revision>
      <id>285</id>
      <timestamp>2020-09-20T18:02:41Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 3]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 3]]</text>
      <sha1>ofcpyhdpql91vz1xr0n32rdrxupv9ff</sha1>
    </revision>
  </page>
  <page>
    <title>3.15</title>
    <ns>0</ns>
    <id>99</id>
    <revision>
      <id>286</id>
      <timestamp>2020-09-20T18:03:24Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 3]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 3]]</text>
      <sha1>ofcpyhdpql91vz1xr0n32rdrxupv9ff</sha1>
    </revision>
  </page>
  <page>
    <title>3.17</title>
    <ns>0</ns>
    <id>100</id>
    <revision>
      <id>287</id>
      <timestamp>2020-09-20T18:03:41Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 3]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 3]]</text>
      <sha1>ofcpyhdpql91vz1xr0n32rdrxupv9ff</sha1>
    </revision>
  </page>
  <page>
    <title>3.19</title>
    <ns>0</ns>
    <id>101</id>
    <revision>
      <id>288</id>
      <timestamp>2020-09-20T18:04:27Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Store two values, the maximum and minimum.  These need to be checked and potentially updated on every delete.  If the minimum is being deleted, call the successor, update the..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="444">Store two values, the maximum and minimum.  These need to be checked and potentially updated on every delete.  If the minimum is being deleted, call the successor, update the minimum and delete the old item.  Similarly, if the maximum is being deleted, call the predecessor, update the maximum and delete the old item.  On insert, compare the new item to min/max, if it replaces either one update the min/max accordingly.

Back to [[Chapter 3]]</text>
      <sha1>llz8o5lal9h4pc58fmwrenaz0pb5qt4</sha1>
    </revision>
  </page>
  <page>
    <title>3.21</title>
    <ns>0</ns>
    <id>102</id>
    <revision>
      <id>289</id>
      <timestamp>2020-09-20T18:05:08Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Since all the elements in S2 have keys larger than the keys of the elements in S1, those two trees can be subtrees of one tree whose root node will have a key larger than the..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="657">Since all the elements in S2 have keys larger than the keys of the elements in S1, those two trees can be subtrees of one tree whose root node will have a key larger than the largest key in S1 and smaller than the smallest key in S2. Then S2 will be the right subtree and S1 the left subtree. The easiest way to do this is to find the minimum element of S2 (or the maximum of S1) and put it as the root of the concatenated tree and than update its left and right pointer to point to the root of S1 and S2 respectively. The worst-case running time will be O(h), which is the time of retrieving the minimum (maximum) element of a tree.


Back to [[Chapter 3]]</text>
      <sha1>s6vywbn9of9fh9ci2m9960plyik92c4</sha1>
    </revision>
  </page>
  <page>
    <title>3.23</title>
    <ns>0</ns>
    <id>103</id>
    <revision>
      <id>290</id>
      <timestamp>2020-09-20T18:05:33Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 3]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 3]]</text>
      <sha1>ofcpyhdpql91vz1xr0n32rdrxupv9ff</sha1>
    </revision>
  </page>
  <page>
    <title>3.25</title>
    <ns>0</ns>
    <id>104</id>
    <revision>
      <id>291</id>
      <timestamp>2020-09-20T18:06:01Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 3]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 3]]</text>
      <sha1>ofcpyhdpql91vz1xr0n32rdrxupv9ff</sha1>
    </revision>
  </page>
  <page>
    <title>3.27</title>
    <ns>0</ns>
    <id>105</id>
    <revision>
      <id>292</id>
      <timestamp>2020-09-20T18:06:40Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Let's put into the black box whole set &lt;math&gt;S=\{x_i\}_{i=1}^n&lt;/math&gt;. If &lt;math&gt;bb(S)&lt;/math&gt; is True, then such a subset exists and we can go on: # R:=S # for i:=1 to n do ##..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="417">Let's put into the black box whole set &lt;math&gt;S=\{x_i\}_{i=1}^n&lt;/math&gt;. If &lt;math&gt;bb(S)&lt;/math&gt; is True, then such a subset exists and we can go on:
# R:=S
# for i:=1 to n do
## If &lt;math&gt;bb(R/\{x_i\})&lt;/math&gt; is True then &lt;math&gt;R:=R/\{x_i\}&lt;/math&gt;
When this iteration is finished R will be subset of S that adds up to k.

Above solution works even when there are multiple subsets that add up to k.


Back to [[Chapter 3]]</text>
      <sha1>m4lts734wypzkxld2zn8br5aan2rjcr</sha1>
    </revision>
  </page>
  <page>
    <title>3.29</title>
    <ns>0</ns>
    <id>106</id>
    <revision>
      <id>293</id>
      <timestamp>2020-09-20T18:08:07Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "In each node of a binary tree store the sub tree sum for the left sub tree.  #''Add'': while descending the tree to the left update the sub tree sum by adding the value #''Ins..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1323">In each node of a binary tree store the sub tree sum for the left sub tree.

#''Add'': while descending the tree to the left update the sub tree sum by adding the value
#''Insert'': same as add, only now we have to add a new node too. To guaranty  &lt;math&gt;O(n \log n)&lt;/math&gt; times we can use any balanced tree types, but the balancing step we have to take care of the sub tree sums. For example in AVL trees balancing operations are tree rotations. If P is the left child of Q, and we are doing a right rotation rooted at Q, than the left sub tree of P remains the same, while the left sub tree of Q will now be the original left sub tree of Q minus the left sub tree of P and P itself. The case of a left rotation is similar. Hence the left sub tree sum values can be maintained in &lt;math&gt;O(1)&lt;/math&gt; during rotation operations.
#''Delete'': When the deleted element has at most 1 child, we only need to update the nodes ancestors. If there are two children, we also need to update elements on the path between the deleted element and it's successor. (The element with which we will swap it before deleting.) 
#''Partial sum'': With the left sub tree sum values stored in the nodes this operation only involves searching for the element with the specified key, and summing sub tree sums along the way.


Back to [[Chapter 3]]</text>
      <sha1>ha231zfkqnwtetymjt2qmcp4wkhhcmg</sha1>
    </revision>
  </page>
  <page>
    <title>3.3</title>
    <ns>0</ns>
    <id>93</id>
    <revision>
      <id>279</id>
      <timestamp>2020-09-20T17:57:59Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "'''C''' &lt;pre&gt; typedef struct Node {     char *value;     struct Node *next; } Node;  int reverse(Node **head) {     Node *curr, *prev, *next;      if (!head || !(*head)) {..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="4259">'''C'''
&lt;pre&gt;
typedef struct Node {
    char *value;
    struct Node *next;
} Node;

int reverse(Node **head) {
    Node *curr, *prev, *next;

    if (!head || !(*head)) {
        return 0;
    }

    curr = *head;
    prev = NULL;
    next = NULL;

    while (curr) {
        next =  curr-&gt;next;
        curr-&gt;next = prev;
        prev = curr;
        curr = next;
    }

    *head = prev;

    return 1;
}
&lt;/pre&gt;
----
'''Dart'''
&lt;pre&gt;
class Node&lt;T&gt; {
  Node(this.value, [this.next]);
  T value;
  Node next;
  @override String toString() =&gt; '$value $next';
}

Node reverse(Node n) {
  Node curr = n.next;
  n.next = null;		// `n` is the new tail.
  while(curr != null) {
    Node tmp = curr.next;	// Start swap.
    curr.next = n;		// next =&gt; previous
    n = curr;			// Update loop's previous node.
    curr = tmp;			// Update loop's current node.
  }
  return n;
}

// Example
void main() {
  final list = Node(1, Node(2, Node(3, Node(4, Node(5)))));
  print(list);			// 1 2 3 4 5 null
  print(reverse(list));		// 5 4 3 2 1 null
}
&lt;/pre&gt;
----

'''In Java
'''
&lt;pre&gt;
class ListNode {
    int val;
    ListNode next;

    ListNode(final int x) {
        val = x;
        next = null;
    }
}

public class LinkedList {
    ListNode head;

    public LinkedList() {
        head = null;
    }

    public void prepend(final int in) {
        final ListNode data = new ListNode(in);
        data.next = head;
        head = data;
    }

    public void appendToList(final int in) {
        final ListNode data = new ListNode(in);
        ListNode current = head;
        if (head == null) {
            head = data;
            return;
        }
        while (current.next != null) {
            current = current.next;
        }
        current.next = data;
    }

    public void printList(final ListNode head) {
        ListNode current = head;
        while (current != null) {
            System.out.print(current.val + " -&gt; ");
            current = current.next;
        }
        System.out.println();
    }
    
    public ListNode reverseList(final ListNode node) {
        //what if 0 node in list
        if (node == null) {
            return null;
        }
        //what if 1 node in list
        if (node.next == null) {
            return node;
        }
        //what if multiple nodes.divide into two parts . reverse second part recursively and in end point second.next to first 
        final ListNode secondElem = node.next;
        node.next = null;
        final ListNode reverseRest = reverseList(secondElem);
        secondElem.next = node;
        return reverseRest;
    }
    
    public static void main(final String[] args) {
        final LinkedList linkedList = new LinkedList();
        linkedList.appendToList(12);
        linkedList.appendToList(13);
        linkedList.appendToList(14);
        linkedList.appendToList(15);
        linkedList.printList(linkedList.head);
        final ListNode head = linkedList.reverseList(linkedList.head);
        linkedList.printList(head);
    }

}
&lt;/pre&gt;

----
'''In Python
'''
&lt;pre&gt;

class Node():
    def __init__(self, value):
        self.value = value
        self.next = None

class LinkedList():
    def __init__(self):
        self.head = None
        self.tail = None

    def add_node(self, value):
        if not self.head:
            self.__initialize_list(value)
        else:
            node = Node(value)
            self.tail.next = node
            self.tail = node

    def print_list(self):
        current_node = self.head

        print('head -&gt;'),
        while current_node is not None:
            print(current_node.value),

            current_node = current_node.next

            print('-&gt;'),

        print('tail')

    def reverse(self):
        current_head = self.head
        head = self.head

        while current_head is not None:
            temp = current_head
            current_head = head.next
            t_next = current_head.next
            head.next = t_next
            current_head.next = temp

            if head.next is None:
                self.head = current_head
                break

    def __initialize_list(self, value):
        self.head = Node(value)
        self.tail = self.head
&lt;/pre&gt;


----

Back to [[Chapter 3]]</text>
      <sha1>qsfo0uxjbatn5q48a3quxaw024gu7kv</sha1>
    </revision>
  </page>
  <page>
    <title>3.31</title>
    <ns>0</ns>
    <id>107</id>
    <revision>
      <id>294</id>
      <timestamp>2020-09-20T18:08:45Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Init:   k=0  Insert X:   k = k+1;    A[X] = k;    B[k] = X;  Search X:   return (A[X] &lt; k) and (B[A[X]] == X)  Delete X:    A[B[k]] = A[X];    B[A[X]] = B[k];    k = k-1;  Ple..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="285">Init:
  k=0

Insert X:
  k = k+1; 
  A[X] = k; 
  B[k] = X;

Search X:
  return (A[X] &lt; k) and (B[A[X]] == X)

Delete X: 
  A[B[k]] = A[X]; 
  B[A[X]] = B[k]; 
  k = k-1;

Please note that this data structure doesn't support inserting the same X more than once.


Back to [[Chapter 3]]</text>
      <sha1>piwsswkgopy38xlnopsxwo7l1x5gqqq</sha1>
    </revision>
  </page>
  <page>
    <title>3.33</title>
    <ns>0</ns>
    <id>108</id>
    <revision>
      <id>295</id>
      <timestamp>2020-09-20T18:09:38Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 3]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 3]]</text>
      <sha1>ofcpyhdpql91vz1xr0n32rdrxupv9ff</sha1>
    </revision>
  </page>
  <page>
    <title>3.35</title>
    <ns>0</ns>
    <id>109</id>
    <revision>
      <id>296</id>
      <timestamp>2020-09-20T18:10:45Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Sort the shirts by color and do a binary search on color.   Back to [[Chapter 3]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="81">Sort the shirts by color and do a binary search on color.


Back to [[Chapter 3]]</text>
      <sha1>2p0nzdgkk48mq0q9eh292y9fzee8ybq</sha1>
    </revision>
  </page>
  <page>
    <title>3.37</title>
    <ns>0</ns>
    <id>110</id>
    <revision>
      <id>298</id>
      <timestamp>2020-09-20T18:12:55Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "&lt;pre&gt; bool compare(struct node* a, struct node* b) {    // 1. both empty -&gt; true   if (a==NULL &amp;&amp; b==NULL) return(true);     // 2. both non-empty -&gt; compare them   else if (a!..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="453">&lt;pre&gt;
bool compare(struct node* a, struct node* b) {

  // 1. both empty -&gt; true
  if (a==NULL &amp;&amp; b==NULL) return(true);   

// 2. both non-empty -&gt; compare them
  else if (a!=NULL &amp;&amp; b!=NULL) {
    return(
      a-&gt;data == b-&gt;data &amp;&amp;
      compare(a-&gt;left, b-&gt;left) &amp;&amp;
      compare(a-&gt;right, b-&gt;right)
    );
  }

  // 3. one empty, one not -&gt; false
  else return(false);
}  
&lt;/pre&gt;
--[[User:Max|Max]] 06:41, 25 June 2010 (EDT)


Back to [[Chapter 3]]</text>
      <sha1>ahqlbr6a23mmny5903ve41qmwnnf3hp</sha1>
    </revision>
  </page>
  <page>
    <title>3.39</title>
    <ns>0</ns>
    <id>111</id>
    <revision>
      <id>299</id>
      <timestamp>2020-09-20T18:14:10Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "== Iterative version with three variables == &lt;pre&gt; Node* ReverseList( Node * List )       {   Node *temp1 = *List;   Node * temp2 = NULL;   Node * temp3 = NULL;   while ( temp..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="2155">== Iterative version with three variables ==
&lt;pre&gt;
Node* ReverseList( Node * List )      
{
  Node *temp1 = *List;
  Node * temp2 = NULL;
  Node * temp3 = NULL;
  while ( temp1 )
  {
        *List = temp1; //set the head to last node           
        temp2= temp1-&gt;pNext; // save the next ptr in temp2
        temp1-&gt;pNext = temp3; // change next to privous
        temp3 = temp1;
        temp1 = temp2;
   }
   return *List;
}
&lt;/pre &gt;

== Iterative version with one variable ==

&lt;pre&gt; 
Node* reverse (node* head)
{
    node *temp=NULL;
    while(true)
    {
        if(head-&gt;next==NULL)
        {
            head-&gt;next=temp;
            break;
        }
        // Swap(head-&gt;next, temp)
        head-&gt;next = (node *)((unsigned long) head-&gt;next ^(unsigned long) temp);
        temp = (node *)((unsigned long) head-&gt;next ^(unsigned long) temp);
        head-&gt;next =(node *) ((unsigned long) head-&gt;next ^ (unsigned long)temp);
        
        // Swap(head, temp)
        head = (node *)((unsigned long) head ^(unsigned long) temp);
        temp =(node *) ((unsigned long) head ^(unsigned long) temp);
        head =(node *) ((unsigned long) head ^ (unsigned long)temp);
        
    }
}
&lt;/pre&gt;


== Recursive Version ==

&lt;pre&gt;
Node* Reverse(Node*head)
{
   Node* temp=NULL;
   if(head==NULL)
   {
       return NULL;
   }
   if(head-&gt;next==NULL)
       return head;
   temp=Reverse(head-&gt;next);
   head-&gt;next-&gt;next=head;
   head-&gt;next=NULL;
   return temp;
}
&lt;/pre&gt;
--[[User:Max|Max]] 07:36, 16 June 2010 (EDT)

== Recursive Version 2 (Java) ==

&lt;pre&gt;
void reverseList(){
	head.reverse(null);
	Node temp=head;
	head=tail;
	tail=temp;
}

public void reverse(Node previousNode){
	if(next!=null)
		next.reverse(this);
	next=previousNode;
}
&lt;/pre&gt;

== Recursive Version 3 (C++) ==

&lt;pre&gt;
struct node{
   int data;
   node* next;
};

node* new_head; // store the new head after calling reverse_sll function

void reverse_sll(node* current_node, node* prev_node=NULL){
   if(current_node==NULL)
      new_head = prev_node;
   else{
      reverse_sll(current_node-&gt;next, current_node);
      current_node-&gt;next=prev_node;
   }
}
&lt;/pre&gt;


Back to [[Chapter 3]]</text>
      <sha1>0r4lbhdii5yvrknsfzspd9wenw9wxch</sha1>
    </revision>
  </page>
  <page>
    <title>3.41</title>
    <ns>0</ns>
    <id>112</id>
    <revision>
      <id>300</id>
      <timestamp>2020-09-20T18:14:52Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Create a count sort in magazine until you find all the characters of given string. --[[User:Max|Max]] 06:49, 25 June 2010 (EDT)   Back to [[Chapter 3]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="151">Create a count sort in magazine until you find all the characters of given string.
--[[User:Max|Max]] 06:49, 25 June 2010 (EDT)


Back to [[Chapter 3]]</text>
      <sha1>ns0y0boo6h474d1o1l7u1bn96hf4zv6</sha1>
    </revision>
  </page>
  <page>
    <title>3.43</title>
    <ns>0</ns>
    <id>113</id>
    <revision>
      <id>301</id>
      <timestamp>2020-09-20T18:16:43Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "&lt;pre&gt; 1) Take two pointers Fast and Slow (Slow jumps one step at a time while Fast two step) 2) While (Fast != NULL)         if(Fast == Slow)               return true;..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="786">&lt;pre&gt;
1) Take two pointers Fast and Slow (Slow jumps one step at a time while Fast two step)
2) While (Fast != NULL)
        if(Fast == Slow)
              return true;
        else
             fast = fast-&gt;next-&gt;next
             slow = slow-&gt;next
3) return false;
After detecting loop stop one pointer and increment other pointer by 1 step untill
Loop
    if (fast == slow)
    break;
else
    slow++
    LoopLength++
EndLoop

You can find out loop start position also.
Once you have LoopLenght.

1. Fast = Slow = Start
2. Fast += LoopLenght
3. Loop
    If Fast != Slow
    Fast++;
    Slow++
EndLoop
4. Fast and Slow Both are pointing to the start of loop position. Now you can break the Loop in link list.
&lt;/pre&gt;
--[[User:Max|Max]] 06:18, 25 June 2010 (EDT)


Back to [[Chapter 3]]</text>
      <sha1>lcwc8ioacv48c4v5xzsbm2g0790vwp4</sha1>
    </revision>
  </page>
  <page>
    <title>3.45</title>
    <ns>0</ns>
    <id>114</id>
    <revision>
      <id>302</id>
      <timestamp>2020-09-20T18:18:11Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with " == Using a Hashtable ==  Scan the web page word by word and for each one, except the first, take the pair formed by the previous word + the current one. Use that pair as the..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="3540">
== Using a Hashtable ==

Scan the web page word by word and for each one, except the first, take the pair formed by the previous word + the current one. Use that pair as the key to a hashtable, where you store the frequency of that pair. If the entry is not already in the hash table store it with value 1, if it is there increment the current value by one. Keep the highest frequency seen and update it wherever you see a greater one. In the end return the greatest frequency seen.

Complexity, where N = number of words in the text:

Time: O(N) (you only iterate over each word once)

Space: O(N) (Worst case is when every word is distinct and thus you have no repeated pairs, and that would take N storage on the hash table)


== Using a Trie ==

The solution with the hashtable will only work in time &lt;math&gt;O(n)&lt;/math&gt; if the hashtable contains &lt;math&gt;m=n&lt;/math&gt; slots (in general, lookup in a hashtable takes &lt;math&gt;O(n/m)&lt;/math&gt; time). Still, this approach could work well if &lt;math&gt;m&lt;/math&gt; is chosen wisely.

Another approach would be to store the text in a trie and save the number of occurrences in the leaf nodes. The implementation below iterates through the text letter by letter (in &lt;math&gt;O(n)&lt;/math&gt; time), using two word pointers &lt;code&gt;word1&lt;/code&gt; and &lt;code&gt;word2&lt;/code&gt; that point to the position in the trie of the current word and the concatenation of the current with the last word, respectively.

If the text is long and natural, it is expected to contain many repetitions and common prefixes, and an efficient implementation would use relatively little memory. Another advantage is that no parameters have to be pre-defined (such as &lt;math&gt;m&lt;/math&gt; in the example using the hashtable).

&lt;source lang="python"&gt;

class Trie:

    def __init__(self, parent=None):
        self.parent = parent
        self.children = {}
        self.n = 0

    def add(self, c):
        return self.children.setdefault(c, Trie(self))

    def letter(self, child):
        for c in self.children:
            if self.children[c] == child:
                return c
        return None

    def spell(self):
        if self.parent:
            return self.parent.spell() + self.parent.letter(self)
        return ''

def wrap(text):
    """iterates through text, yielding lowercase letter or single ' '"""
    inword = False
    for c in text:
        c = c.lower()
        if ord(c) &gt;= ord('a') and ord(c) &lt;= ord('z'):
            yield c
            inword = True
        else:
            if inword:
                yield ' '
            inword = False
    if inword:
        yield ' '

def pairmax(text):
    """finds the word pair with maximum occurrence"""
    root = word2 = Trie()
    best = word1 = None
    for c in wrap(text):
        if c == ' ':
            if word1:
                word2.n += 1
                if best is None or word2.n &gt; best.n:
                    best = word2
                word2 = word1.add(' ')
                word1 = root
            else:
                word1 = root
                word2 = word2.add(' ')
        else:
            word2 = word2.add(c)
            if word1:
                word1 = word1.add(c)
    return best.spell(), best.n


if __name__ == '__main__':
    import urllib2, sys

    urls = sys.argv[1:]
    if not urls:
        urls = ['http://www.rfc-editor.org/rfc/rfc19%02d.txt' % i for i in range(30, 40)]

    for url in urls:
        word, n = pairmax(urllib2.urlopen(url).read())
        sys.stdout.write('%s : %dx "%s"\n' %(url, n, word))
&lt;/source&gt;


Back to [[Chapter 3]]</text>
      <sha1>s4dyiy0cut5q5f53l2ap30lqnek0d2a</sha1>
    </revision>
  </page>
  <page>
    <title>3.5</title>
    <ns>0</ns>
    <id>94</id>
    <revision>
      <id>280</id>
      <timestamp>2020-09-20T17:59:03Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "1. size 4 array with 3 elements. remove 1, insert 1, and so forth. &lt;br&gt; 2. when the array is one-fourth full, shrink its size to half of what it was.   Back to [[Chaprer 3]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="173">1. size 4 array with 3 elements. remove 1, insert 1, and so forth. &lt;br&gt;
2. when the array is one-fourth full, shrink its size to half of what it was.


Back to [[Chaprer 3]]</text>
      <sha1>recab4ulk60vdxy8huipf35lwctarzv</sha1>
    </revision>
    <revision>
      <id>281</id>
      <parentid>280</parentid>
      <timestamp>2020-09-20T17:59:16Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="173">1. size 4 array with 3 elements. remove 1, insert 1, and so forth. &lt;br&gt;
2. when the array is one-fourth full, shrink its size to half of what it was.


Back to [[Chapter 3]]</text>
      <sha1>kj7jii374az0x4ulo0ft4cmixglfdp0</sha1>
    </revision>
  </page>
  <page>
    <title>3.7</title>
    <ns>0</ns>
    <id>95</id>
    <revision>
      <id>282</id>
      <timestamp>2020-09-20T17:59:47Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 3]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 3]]</text>
      <sha1>ofcpyhdpql91vz1xr0n32rdrxupv9ff</sha1>
    </revision>
  </page>
  <page>
    <title>3.9</title>
    <ns>0</ns>
    <id>96</id>
    <revision>
      <id>283</id>
      <timestamp>2020-09-20T18:00:56Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 3]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 3]]</text>
      <sha1>ofcpyhdpql91vz1xr0n32rdrxupv9ff</sha1>
    </revision>
  </page>
  <page>
    <title>4.1</title>
    <ns>0</ns>
    <id>115</id>
    <revision>
      <id>303</id>
      <timestamp>2020-09-20T18:20:00Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Sort it with your favorite nlogn sorting algo.  The bottom half is one team, the top half the other.  Or much better , partition it with median as pivot . Time complexity O(n)..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="200">Sort it with your favorite nlogn sorting algo.  The bottom half is one team, the top half the other.

Or much better , partition it with median as pivot . Time complexity O(n).


Back to [[Chapter 3]]</text>
      <sha1>6797o9cp5e93ll0jzfl1wojjqmub67g</sha1>
    </revision>
    <revision>
      <id>304</id>
      <parentid>303</parentid>
      <timestamp>2020-09-20T18:20:25Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="203">Sort it with your favorite nlogn sorting algorithm.  The bottom half is one team, the top half the other.

Or much better, partition it with median as pivot. Time complexity O(n).


Back to [[Chapter 4]]</text>
      <sha1>je7w333qx7642ace0hpkouuv7xuidrl</sha1>
    </revision>
  </page>
  <page>
    <title>4.11</title>
    <ns>0</ns>
    <id>120</id>
    <revision>
      <id>310</id>
      <timestamp>2020-09-20T18:24:04Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Note that there can be at most one element which appears more than n/2 (i.e. at least ceil(n/2) ) times in the list.  If we now consider the *sorted* version of the list, we'l..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="3256">Note that there can be at most one element which appears more than n/2 (i.e. at least ceil(n/2) ) times in the list.

If we now consider the *sorted* version of the list, we'll see that if such an element exists, it covers 
a consecutive range in the list. The start of this range can be at various places with the extreme
cases being:

* the range starts at element 1
* the range ends at element n

We can easily see that in both cases (and therefore also in the cases between the extremes) that if there
is an element which appears more than n/2 times, the element at position ceil(n/2) (in the sorted list) must have this value.

This leads to the following algorithm:

   Determine the ceil(n/2) smallest element of the (unsorted) set. The [http://en.wikipedia.org/wiki/Selection_algorithm#Linear_general_selection_algorithm_-_Median_of_Medians_algorithm BFPRT] algorithm can do that in O(n) running time in the worst case .

   Go through the list element by element and count the number of occurrences of this ceil(n/2) smallest element.
   If it occurs at more than n/2 times, this is the element we were looking for, otherwise the list does not contain such an element.

----
Alternatively, successively remove pairs of distinct elements from the list.  If there is an element that appears more than n/2 times, it won't have a pair eventually.  The algorithm below removes pairs of distinct elements from the list until the residual list (maybe empty) contains only equal elements.  If the residual list is non-empty, its head is a candidate for the element that appears more than n/2 times.  Whether it is so can be checked in one linear sweep.  If the residual list is empty, the list doesn't contain an element that appears more than n/2 times.

The algorithm works as follows.  We traverse the list recursively and maintain an additional stack.  The stack is initially empty.  If both the list and stack are non-empty, then either the top of the stack is distinct from the head of the list, in which case they both can be removed, or they are equal, in which case we move the head of the list to the top of the stack, thus maintaining the invariant that the stack contains only equal elements.  If the stack becomes empty, but there are still elements in the list, we move the head of the list onto the stack.  If the list becomes empty, the stack contains elements for which there was no pair.  We can implement this algorithm in Haskell as follows:

    candidates :: Eq a =&gt; [a] -&gt; [a]
    candidates = go []
        where
          go ys []     = ys
          go [] (x:xs) = go [x] xs
          go (y:ys) (x:xs)
              | y == x = go (x:y:ys) xs
              | y /= x = go ys xs

----
== Algorithm for any arbitrary number of occurrences ==
For each element insert it into a dictionary. If the element is not in the dictionary add it with a count of one, if it is already in the dictionary increment its value. This can be done in linear time and space if using something like a hash function. 
Each time we change the count of an element we check if its frequency exceeds the number we are looking for. If it does we either save it or return it, depending on whether we want to find one or all such elements.


Back to [[Chapter 4]]</text>
      <sha1>8uz3qo6f0zbod10i5il5v85s7yd9wht</sha1>
    </revision>
  </page>
  <page>
    <title>4.13</title>
    <ns>0</ns>
    <id>121</id>
    <revision>
      <id>311</id>
      <timestamp>2020-09-20T18:25:03Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 4]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 4]]</text>
      <sha1>obozfu8bihzc95wg0ic0bxarr8k70d2</sha1>
    </revision>
  </page>
  <page>
    <title>4.15</title>
    <ns>0</ns>
    <id>122</id>
    <revision>
      <id>312</id>
      <timestamp>2020-09-20T18:25:06Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 4]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 4]]</text>
      <sha1>obozfu8bihzc95wg0ic0bxarr8k70d2</sha1>
    </revision>
  </page>
  <page>
    <title>4.17</title>
    <ns>0</ns>
    <id>123</id>
    <revision>
      <id>313</id>
      <timestamp>2020-09-20T18:25:52Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Scan through the array to build an out-of-order heap, that is, the first element is indeed the smallest, but necessarily any of the other elements. This takes us O(n). Then ex..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="539">Scan through the array to build an out-of-order heap, that is, the first element is indeed the smallest, but necessarily any of the other elements. This takes us O(n).
Then extract from the heap k times to get the smallest k elements using O(klogn).
Thus the total time is O(n+klogn).

Other solution:
Create a heap using bubble down per 4.3.4 in the book. This takes O(n) time. Then, extract from the heap in k times to get the smallest k elements. This takes O(k*logn) time. Therefore, total time is O(n + k*logn)


Back to [[Chapter 4]]</text>
      <sha1>28mbo8c8duqykqqvqnlf4cog1gszdv2</sha1>
    </revision>
  </page>
  <page>
    <title>4.19</title>
    <ns>0</ns>
    <id>124</id>
    <revision>
      <id>314</id>
      <timestamp>2020-09-20T18:26:26Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "1) Finding the maximum element is O(1) in both a max-heap (the root of the heap) and a sorted array (the last element in the array), so for this operation, both data structure..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="900">1) Finding the maximum element is O(1) in both a max-heap (the root of the heap) and a sorted array (the last element in the array), so for this operation, both data structures are equally optimal. (The max-heap is ''marginally'' faster, since the array length doesn't need to be accessed, but this splits hairs.)

2) Assuming the index of the element is known, a deletion on a heap costs O(log n) time to bubble down.  A sorted array requires all elements to be updated leading to a O(n) operation.

3) A heap can be formed in O(n) time.  The sorted array will require a sort costing O(n log n).

4) Finding the minimum element in a max-heap requires visiting each of the leaf nodes in the worst case, i.e. is an O(n) operation. Finding the minimum element in a sorted array is an O(1) operation (it's the first element), so the sorted array performs (asymptotically) better.


Back to [[Chapter 4]]</text>
      <sha1>33yjwn1sypc6nfxdo8ivcv8krtolwcj</sha1>
    </revision>
  </page>
  <page>
    <title>4.21</title>
    <ns>0</ns>
    <id>125</id>
    <revision>
      <id>315</id>
      <timestamp>2020-09-20T18:27:20Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "the general form of this problem is to find the kth largest value.  finding the median is when k = n/2.  to find the kth largest value, * select a partition element and split..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="992">the general form of this problem is to find the kth largest value.  finding the median is when k = n/2.

to find the kth largest value,
* select a partition element and split the array into 2 sub-arrays - one with the elements smaller than the partition and one with the elements larger than the partition. '''O(n)'''
* if the array with the elements larger than the partition has k - 1 elements, the partition is the kth largest element
* if the array with the elements larger than the partition has &gt;= k elements, recurse with the same value of k using the larger elements as the new array. '''O(n/2)''' (average case)
* else the median is in the array with elements smaller than the partition so adjust k to account for the large elements being discarded and recurse using the smaller elements as the new array '''O(n/2)''' (average case)

the overall complexity is O(n) since

O(n) + O(n/2) + O(n/4) + ... approaches O(2n) which is just O(n) since 2 is a constant.


Back to [[Chapter 4]]</text>
      <sha1>965s9uhgsgutfvyhqlus490frvejg23</sha1>
    </revision>
  </page>
  <page>
    <title>4.23</title>
    <ns>0</ns>
    <id>126</id>
    <revision>
      <id>316</id>
      <timestamp>2020-09-20T18:28:01Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "&lt;pre&gt; from random import choices   def group_by_color(data, start, stop, color):     operations_counter = 0      while start &lt; stop and start &lt; len(data) and stop &gt;= 0:..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1721">&lt;pre&gt;
from random import choices


def group_by_color(data, start, stop, color):
    operations_counter = 0

    while start &lt; stop and start &lt; len(data) and stop &gt;= 0:
        # data[start] is equal to examine(data[start]) except swap function call

        while start &lt; len(data) and data[start] == color:  # Finding first element with incorrect color from start
            start += 1  # Element with correct color already on right position, moving forward
            operations_counter += 1

        while start &lt; stop and stop &gt;= 0 and data[stop] != color:  # Finding first element with correct color from end
            stop -= 1  # Element with incorrect color will be swapped later or keep on that position, moving backward
            operations_counter += 1

        if start &lt; stop:
            data[start], data[stop] = data[stop], data[start]  # Equal to swap(start, stop)
            operations_counter += 1

    assert operations_counter &lt;= len(data) * 2  # Check O(2*n) restriction
    return start  # Return last element with specified color


colors_list = choices(['red', 'white', 'blue'], k=100)
red_ending = group_by_color(colors_list, 0, len(colors_list) - 1, 'red')  # Sort red O(n)
group_by_color(colors_list, red_ending + 1, len(colors_list) - 1, 'white')  # Sort white O(n)
# Blue already sorted
&lt;/pre&gt;

First pass: group red elements from 0 to k. Swapping not red elements found from begin and red elements found from end.

Second pass: group white elements from k to j. Swapping not white elements from k and white elements from end.

Blue elements already grouped from j to n.

--[[User:Bkarpov96|Bkarpov96]] ([[User talk:Bkarpov96|talk]]) 17:36, 19 June 2020 (UTC)


Back to [[Chapter 4]]</text>
      <sha1>j5oy0qoj6fnnwyet59gbhs8l45myf1c</sha1>
    </revision>
  </page>
  <page>
    <title>4.25</title>
    <ns>0</ns>
    <id>127</id>
    <revision>
      <id>317</id>
      <timestamp>2020-09-20T18:28:31Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 4]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 4]]</text>
      <sha1>obozfu8bihzc95wg0ic0bxarr8k70d2</sha1>
    </revision>
  </page>
  <page>
    <title>4.27</title>
    <ns>0</ns>
    <id>128</id>
    <revision>
      <id>318</id>
      <timestamp>2020-09-20T18:28:40Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 4]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 4]]</text>
      <sha1>obozfu8bihzc95wg0ic0bxarr8k70d2</sha1>
    </revision>
  </page>
  <page>
    <title>4.29</title>
    <ns>0</ns>
    <id>129</id>
    <revision>
      <id>319</id>
      <timestamp>2020-09-20T18:28:54Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 4]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 4]]</text>
      <sha1>obozfu8bihzc95wg0ic0bxarr8k70d2</sha1>
    </revision>
  </page>
  <page>
    <title>4.3</title>
    <ns>0</ns>
    <id>116</id>
    <revision>
      <id>305</id>
      <timestamp>2020-09-20T18:20:58Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "&lt;pre&gt; Algo - If we create pair of (min1, max2n) (min1, max2n-1)... will provide optimal result 1) Sort the set of 2n element (n log n) 2) Now assign two pointers     Start: A[..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="354">&lt;pre&gt;
Algo -
If we create pair of (min1, max2n) (min1, max2n-1)... will provide optimal result
1) Sort the set of 2n element (n log n)
2) Now assign two pointers 
   Start: A[0]
   End:   A[2n-1]
   while (start &lt; end)
      pair(start, end)
      start++
      end--
   EndLoop
&lt;/pre&gt;
--[[User:Max|Max]] 06:55, 25 June 2010 (EDT)


Back to [[Chapter 4]]</text>
      <sha1>9px7f3ywy7f36v13cn3u83tjq1kptor</sha1>
    </revision>
  </page>
  <page>
    <title>4.31</title>
    <ns>0</ns>
    <id>130</id>
    <revision>
      <id>320</id>
      <timestamp>2020-09-20T18:29:31Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "To guarantee mergesort is stable, when merging the two subarrays together, mergesort should settle ties in the lists by choosing the lower indexed value.   Back to [[Chapter 4]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="177">To guarantee mergesort is stable, when merging the two subarrays together, mergesort should settle ties in the lists by choosing the lower indexed value.


Back to [[Chapter 4]]</text>
      <sha1>n7fz558p4hp8kv7m7lxjtifrodorde1</sha1>
    </revision>
  </page>
  <page>
    <title>4.33</title>
    <ns>0</ns>
    <id>131</id>
    <revision>
      <id>321</id>
      <timestamp>2020-09-20T18:30:06Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 4]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 4]]</text>
      <sha1>obozfu8bihzc95wg0ic0bxarr8k70d2</sha1>
    </revision>
  </page>
  <page>
    <title>4.35</title>
    <ns>0</ns>
    <id>132</id>
    <revision>
      <id>322</id>
      <timestamp>2020-09-20T18:30:31Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "It's not clear to me if the first &lt;math&gt;n - \sqrt n&lt;/math&gt; element being sorted means that the remaining &lt;math&gt;\sqrt n&lt;/math&gt; elements are all bigger or not, but let's suppose..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="668">It's not clear to me if the first &lt;math&gt;n - \sqrt n&lt;/math&gt; element being sorted means that the remaining &lt;math&gt;\sqrt n&lt;/math&gt; elements are all bigger or not, but let's suppose they are not, since that's more general.

First sort the remaining &lt;math&gt;\sqrt n&lt;/math&gt; elements in &lt;math&gt;O(\sqrt n \log \sqrt n)&lt;/math&gt; time. After that we can do a simple merge step to merge the two sorted arrays in &lt;math&gt;O(n)&lt;/math&gt; time. Since &lt;math&gt;\sqrt n&lt;/math&gt; dominates &lt;math&gt;\log \sqrt n&lt;/math&gt; we can come to the conclusion that the total running time of this algorithm is: &lt;math&gt;O(\sqrt n \log \sqrt n + n) = O(\sqrt n \sqrt n + n) = O(n + n) = O(n)&lt;/math&gt;


Back to [[Chapter 4]]</text>
      <sha1>47w5e5y66n5mbavpdnki9f08al39x6d</sha1>
    </revision>
  </page>
  <page>
    <title>4.37</title>
    <ns>0</ns>
    <id>133</id>
    <revision>
      <id>323</id>
      <timestamp>2020-09-20T18:30:59Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 4]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 4]]</text>
      <sha1>obozfu8bihzc95wg0ic0bxarr8k70d2</sha1>
    </revision>
  </page>
  <page>
    <title>4.39</title>
    <ns>0</ns>
    <id>134</id>
    <revision>
      <id>324</id>
      <timestamp>2020-09-20T18:31:39Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 4]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 4]]</text>
      <sha1>obozfu8bihzc95wg0ic0bxarr8k70d2</sha1>
    </revision>
  </page>
  <page>
    <title>4.41</title>
    <ns>0</ns>
    <id>135</id>
    <revision>
      <id>325</id>
      <timestamp>2020-09-20T18:32:17Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 4]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 4]]</text>
      <sha1>obozfu8bihzc95wg0ic0bxarr8k70d2</sha1>
    </revision>
  </page>
  <page>
    <title>4.43</title>
    <ns>0</ns>
    <id>136</id>
    <revision>
      <id>326</id>
      <timestamp>2020-09-20T18:32:51Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 4]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 4]]</text>
      <sha1>obozfu8bihzc95wg0ic0bxarr8k70d2</sha1>
    </revision>
  </page>
  <page>
    <title>4.45</title>
    <ns>0</ns>
    <id>137</id>
    <revision>
      <id>327</id>
      <timestamp>2020-09-20T18:33:06Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 4]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 4]]</text>
      <sha1>obozfu8bihzc95wg0ic0bxarr8k70d2</sha1>
    </revision>
  </page>
  <page>
    <title>4.47</title>
    <ns>0</ns>
    <id>138</id>
    <revision>
      <id>328</id>
      <timestamp>2020-09-20T18:34:09Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with " For a known set of integer numbers ( assume Nr-1, Nr-2 ... Nr-k) the best is to use a non-comparison based sort algorithm like radix sort with O(n)  You have an array that cr..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="475">
For a known set of integer numbers ( assume Nr-1, Nr-2 ... Nr-k) the best is to use a non-comparison based sort algorithm like radix sort with O(n)

You have an array that creates a histogram of all numbers ( histoThenStartIndexArray[Nr-i]++)

Step 2, in the same array calculate the index of that position 
For example if there are 3 numbers 99, and 5 numbers 105, the next index will be 8 for the next number

Step 3, parse array and display values


Back to [[Chapter 4]]</text>
      <sha1>55ri84d693lr09wam55runmjv7xou5e</sha1>
    </revision>
  </page>
  <page>
    <title>4.49</title>
    <ns>0</ns>
    <id>139</id>
    <revision>
      <id>329</id>
      <timestamp>2020-09-20T18:35:35Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 4]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 4]]</text>
      <sha1>obozfu8bihzc95wg0ic0bxarr8k70d2</sha1>
    </revision>
  </page>
  <page>
    <title>4.5</title>
    <ns>0</ns>
    <id>117</id>
    <revision>
      <id>306</id>
      <timestamp>2020-09-20T18:21:48Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "O(nlogn) solution: : sort the array first,  : scan the array, keep updating a max_so_far counter.   O(n) solution: : put each value into hash map with the value as key and fre..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="250">O(nlogn) solution:
: sort the array first, 
: scan the array, keep updating a max_so_far counter.


O(n) solution:
: put each value into hash map with the value as key and frequency as value
: scan the hash map to find the max


Back to [[Chapter 4]]</text>
      <sha1>ca4zh3n6ez1ga03bp1a5beruumish8n</sha1>
    </revision>
  </page>
  <page>
    <title>4.51</title>
    <ns>0</ns>
    <id>141</id>
    <revision>
      <id>332</id>
      <timestamp>2020-09-20T18:36:56Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "If we are allowed to maintain a second stack on the side, this should be possible. The main stack is a regular stack that can be implemented using an array and an index to the..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="802">If we are allowed to maintain a second stack on the side, this should be possible.
The main stack is a regular stack that can be implemented using an array and an index to the top of the stack.
The second stack will stack each entry when it becomes the new minimum, only.
When an entry is popped from the main stack, it will be poped from the second stack only if identical.
The minimum item is the top of the second stack.


I think the actual question was about ability of building the stack that has push/pop/extract-min operations as in the queues - the extract removes element. This is impossible - that would give us an opportunity to sort in O(n) time (n O(1) pushes to the data structure, and then n extract-min's)
--[[User:Kubek2k|Kubek2k]] 05:00, 6 November 2011 (EST)


Back to [[Chapter 4]]</text>
      <sha1>hjayzg9d1fvo4wnto9n1dhm65krhhs3</sha1>
    </revision>
  </page>
  <page>
    <title>4.53</title>
    <ns>0</ns>
    <id>140</id>
    <revision>
      <id>330</id>
      <timestamp>2020-09-20T18:36:16Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "If we are allowed to maintain a second stack on the side, this should be possible. The main stack is a regular stack that can be implemented using an array and an index to the..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="802">If we are allowed to maintain a second stack on the side, this should be possible.
The main stack is a regular stack that can be implemented using an array and an index to the top of the stack.
The second stack will stack each entry when it becomes the new minimum, only.
When an entry is popped from the main stack, it will be poped from the second stack only if identical.
The minimum item is the top of the second stack.


I think the actual question was about ability of building the stack that has push/pop/extract-min operations as in the queues - the extract removes element. This is impossible - that would give us an opportunity to sort in O(n) time (n O(1) pushes to the data structure, and then n extract-min's)
--[[User:Kubek2k|Kubek2k]] 05:00, 6 November 2011 (EST)


Back to [[Chpater 4]]</text>
      <sha1>poserbuha91ibbrjqfnuv132bfg7rky</sha1>
    </revision>
    <revision>
      <id>331</id>
      <parentid>330</parentid>
      <timestamp>2020-09-20T18:36:26Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="802">If we are allowed to maintain a second stack on the side, this should be possible.
The main stack is a regular stack that can be implemented using an array and an index to the top of the stack.
The second stack will stack each entry when it becomes the new minimum, only.
When an entry is popped from the main stack, it will be poped from the second stack only if identical.
The minimum item is the top of the second stack.


I think the actual question was about ability of building the stack that has push/pop/extract-min operations as in the queues - the extract removes element. This is impossible - that would give us an opportunity to sort in O(n) time (n O(1) pushes to the data structure, and then n extract-min's)
--[[User:Kubek2k|Kubek2k]] 05:00, 6 November 2011 (EST)


Back to [[Chapter 4]]</text>
      <sha1>hjayzg9d1fvo4wnto9n1dhm65krhhs3</sha1>
    </revision>
    <revision>
      <id>333</id>
      <parentid>331</parentid>
      <timestamp>2020-09-20T18:37:29Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="2780">Question: You are given 12 coins. One of them is heavier or lighter than the rest. Identify
this coin in just three weighings

Solution:
Number the coins 1 through 12 and divide them coins into 4 sets of 3...

There are multiple comparison sets possible. This is an acceptable template to find a few of them.
(This template is NOT definitive, there are other solutions that don't follow this template) 

 Compare   (set 1 &amp; 1st coin from set 4)  against  (set 2 + 2nd coin from set 4)
 Compare   (set 1 &amp; 2nd coin from set 4)  against  (set 3 + 1st coin from set 4)
 Compare   (1st coin from each set)       against  (3rd coin from each set)

A more concise example:

 Compare   1 2 3 10  against  4 5 6 11
 Compare   1 2 3 11  against  7 8 9 10
 Compare   1 4 7 10  against  3 6 9 12

Each weighing can have 3 possible outcomes: Left Heavy, Right Heavy, or Balanced (L,R or B)

Build a truth table to interpret outcomes...many outcomes are not possible.
Note: THE TABLE VALUES ARE DERIVED FROM THE CHOSEN COMPARISON SETS!

 outcome:    fake coin:
 l l l       1 is heavy
 r r r       1 is light
 l l b       2 is heavy
 r r b       2 is light
 l l r       3 is heavy
 r r l       3 is light
 r b l       4 is heavy
 l b r       4 is light
 r b b       5 is heavy
 l b b       5 is light
 r b r       6 is heavy
 l b l       6 is light
 b r l       7 is heavy
 b l r       7 is light
 b r b       8 is heavy
 b l b       8 is light
 b r r       9 is heavy 
 b l l       9 is light
 r l r       10 is heavy
 l r l       10 is light
 l r b       11 is heavy
 r l b       11 is light
 b b r       12 is heavy
 b b l       12 is light 

There are multiple comparison set possibilities, each with their own comparison table solution.

----

A simpler solution #2:

* put 6 coins on each side of the scale, one side will be heavier.
* use the heavier side from the first weighing and put 3 coins on each side of the scale.
* using the heavier side from the 2nd weighing, pick 2 coins and put 1 on each side of the scale.

If the scale is balanced then the coin you didn't weigh is the heavier one.  Otherwise, the scale will show which one of the other 2 is the heavy coin.

----

Since we do not know if the faulty coin is heavier or lighter , the soluition #2 is not correct 

The only solution is solution nr 1, for which we can also use a binary tree

----

I found the explanation at mathforum.org/library/drmath/view/55618.html to be helpful. The key is to build a truth table, but how that table was built is a little tricky because you can't just write out all possible combinations of results and use that. I tried writing a truth table and found that I had to swap some values around to make sure that each measurement step had exactly 4 on each side.


Back to [[Chapter 4]]</text>
      <sha1>aprzsond6xfpq0vjgk61z43mhgjyytc</sha1>
    </revision>
  </page>
  <page>
    <title>4.7</title>
    <ns>0</ns>
    <id>118</id>
    <revision>
      <id>307</id>
      <timestamp>2020-09-20T18:22:24Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 4]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 4]]</text>
      <sha1>obozfu8bihzc95wg0ic0bxarr8k70d2</sha1>
    </revision>
  </page>
  <page>
    <title>4.9</title>
    <ns>0</ns>
    <id>119</id>
    <revision>
      <id>308</id>
      <timestamp>2020-09-20T18:23:01Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Here the main thing to notice is that we need a O(&lt;math&gt;n^{k-1}logn&lt;/math&gt;) solution. &lt;br /&gt; For various values of k,  &lt;br /&gt; k       Solution Time Complexity &lt;br /&gt; 1       O..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="3167">Here the main thing to notice is that we need a O(&lt;math&gt;n^{k-1}logn&lt;/math&gt;) solution. &lt;br /&gt;
For various values of k,  &lt;br /&gt;
k       Solution Time Complexity &lt;br /&gt;
1       O(&lt;math&gt;n^0logn&lt;/math&gt;) &lt;br /&gt;
2       O(&lt;math&gt;n^1logn&lt;/math&gt;) &lt;br /&gt;
3       O(&lt;math&gt;n^2logn&lt;/math&gt;) &lt;br /&gt;
4       O(&lt;math&gt;n^3logn&lt;/math&gt;) &lt;br /&gt;

for k = 2 onwards &lt;br /&gt;
1. sort the array ( nlogn ) &lt;br /&gt;
2. use k-1 loops for iterating over array, where ith loop starts from i-1 + 1 element of array, and then use binary search &lt;br /&gt;
eg: &lt;br /&gt;
for k = 3 &lt;br /&gt;
for( i = 0; i &lt; n; i++ ) &lt;br /&gt;
for( j = i+1; j &lt; n; j++ ) &lt;br /&gt;
# now use binary search to find ( T - a[i] - a[j] ) from j+1 element to end of array &lt;br /&gt;

&lt;h3&gt;Another recursive solution&lt;/h3&gt;
First, we note that [[ TADM2E 4.8 | an O(&lt;math&gt;n \lg n&lt;/math&gt;) solution for &lt;math&gt;k = 2&lt;/math&gt; exists ]], which is already within the required bounds. Now, for &lt;math&gt;k \ge 3&lt;/math&gt;, we can do something like this:

&lt;pre&gt;
sort S ascending;
CheckSumOfK(S, k, T); // defined below

// S must be aorted array of integers
function CheckSumOfK(S, k, T)
    if k &lt;= 2:
        Use any method in the solution of ex 4.8 and return the result. This can be done in O(n) time because S is sorted.

    Initialize array A of n - 1 elements;
    for i from 0 to n - 1:
        k = 0
        // Collect in A all numbers in S but S[i]. Note that A will still be sorted.
        for j from 0 to n - 1:
            if i != j:
                A[k] = S[j];
                k = k + 1
        // If S[i] is included in the k integers that sum up to T, then there must
        // exactly (k - 1) integers in the rest of S (i.e., A) that sum to (T - S[i]).
        // We can find that out by calling ourselves recursively.
        if CheckSumOfK(A, k - 1, T - S[i]):
            return True
    return False
&lt;/pre&gt;

&lt;h3&gt;Complexity&lt;/h3&gt;
For each item in S, there is &lt;math&gt;O(n)&lt;/math&gt; work done in assembling the array A, except at the &lt;math&gt;{k - 1}^{th}&lt;/math&gt; recursive call, which completes in &lt;math&gt;O(n \lg n)&lt;/math&gt; time. So, for each number in S, we have &lt;math&gt;O(kn) + O(n \lg n)&lt;/math&gt; work, and since &lt;math&gt;k &lt;= n&lt;/math&gt;, each iteration of the outer loop takes &lt;math&gt;O(n^2) + O(n \lg n) = O(n^2)&lt;/math&gt;
work. Now since the outer loop goes on for at most &lt;math&gt;n&lt;/math&gt; iterations, we have a total runtime of &lt;math&gt;O(n^3)&lt;/math&gt;.

A trick can be used to lower this runtime to &lt;math&gt;O(n^2 \lg n)&lt;/math&gt; by having the routines in [[ TADM2E 4.8 | this solution ]] take an index to ignore when iterating in their inner loops. With this, we save the &lt;math&gt;O(n)&lt;/math&gt; construction of A for every
item, and then each iteration of the outer loop becomes &lt;math&gt;O(n \lg n)&lt;/math&gt; (How? &lt;math&gt;O(k) = O(n)&lt;/math&gt; constant time recursive calls plus &lt;math&gt;O(n \lg n)&lt;/math&gt; time spent in the &lt;math&gt;{k - 1}^{th}&lt;/math&gt; calls), giving a total runtime of &lt;math&gt;O(n^2 \lg n)&lt;/math&gt; for &lt;math&gt;n&lt;/math&gt; elements in S.

Note that this cost includes the initial &lt;math&gt;O(n \lg n)&lt;/math&gt; cost for sorting S. Also, this algorithm is always going to be &lt;math&gt;O(n^{k-1} \lg n)&lt;/math&gt; for all &lt;math&gt;k &gt;= 2&lt;/math&gt;. The exercise just states an upper bound.


Back to [[Chapter 4]]</text>
      <sha1>srofrs938ygx75jqzb3bst0lusce1uc</sha1>
    </revision>
    <revision>
      <id>309</id>
      <parentid>308</parentid>
      <timestamp>2020-09-20T18:23:24Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="3148">Here the main thing to notice is that we need a O(&lt;math&gt;n^{k-1}logn&lt;/math&gt;) solution. &lt;br /&gt;
For various values of k,  &lt;br /&gt;
k       Solution Time Complexity &lt;br /&gt;
1       O(&lt;math&gt;n^0logn&lt;/math&gt;) &lt;br /&gt;
2       O(&lt;math&gt;n^1logn&lt;/math&gt;) &lt;br /&gt;
3       O(&lt;math&gt;n^2logn&lt;/math&gt;) &lt;br /&gt;
4       O(&lt;math&gt;n^3logn&lt;/math&gt;) &lt;br /&gt;

for k = 2 onwards &lt;br /&gt;
1. sort the array ( nlogn ) &lt;br /&gt;
2. use k-1 loops for iterating over array, where ith loop starts from i-1 + 1 element of array, and then use binary search &lt;br /&gt;
eg: &lt;br /&gt;
for k = 3 &lt;br /&gt;
for( i = 0; i &lt; n; i++ ) &lt;br /&gt;
for( j = i+1; j &lt; n; j++ ) &lt;br /&gt;
# now use binary search to find ( T - a[i] - a[j] ) from j+1 element to end of array &lt;br /&gt;

&lt;h3&gt;Another recursive solution&lt;/h3&gt;
First, we note that an O(&lt;math&gt;n \lg n&lt;/math&gt;) solution for &lt;math&gt;k = 2&lt;/math&gt; exists, which is already within the required bounds. Now, for &lt;math&gt;k \ge 3&lt;/math&gt;, we can do something like this:

&lt;pre&gt;
sort S ascending;
CheckSumOfK(S, k, T); // defined below

// S must be aorted array of integers
function CheckSumOfK(S, k, T)
    if k &lt;= 2:
        Use any method in the solution of ex 4.8 and return the result. This can be done in O(n) time because S is sorted.

    Initialize array A of n - 1 elements;
    for i from 0 to n - 1:
        k = 0
        // Collect in A all numbers in S but S[i]. Note that A will still be sorted.
        for j from 0 to n - 1:
            if i != j:
                A[k] = S[j];
                k = k + 1
        // If S[i] is included in the k integers that sum up to T, then there must
        // exactly (k - 1) integers in the rest of S (i.e., A) that sum to (T - S[i]).
        // We can find that out by calling ourselves recursively.
        if CheckSumOfK(A, k - 1, T - S[i]):
            return True
    return False
&lt;/pre&gt;

&lt;h3&gt;Complexity&lt;/h3&gt;
For each item in S, there is &lt;math&gt;O(n)&lt;/math&gt; work done in assembling the array A, except at the &lt;math&gt;{k - 1}^{th}&lt;/math&gt; recursive call, which completes in &lt;math&gt;O(n \lg n)&lt;/math&gt; time. So, for each number in S, we have &lt;math&gt;O(kn) + O(n \lg n)&lt;/math&gt; work, and since &lt;math&gt;k &lt;= n&lt;/math&gt;, each iteration of the outer loop takes &lt;math&gt;O(n^2) + O(n \lg n) = O(n^2)&lt;/math&gt;
work. Now since the outer loop goes on for at most &lt;math&gt;n&lt;/math&gt; iterations, we have a total runtime of &lt;math&gt;O(n^3)&lt;/math&gt;.

A trick can be used to lower this runtime to &lt;math&gt;O(n^2 \lg n)&lt;/math&gt; by having the routines in [[ TADM2E 4.8 | this solution ]] take an index to ignore when iterating in their inner loops. With this, we save the &lt;math&gt;O(n)&lt;/math&gt; construction of A for every
item, and then each iteration of the outer loop becomes &lt;math&gt;O(n \lg n)&lt;/math&gt; (How? &lt;math&gt;O(k) = O(n)&lt;/math&gt; constant time recursive calls plus &lt;math&gt;O(n \lg n)&lt;/math&gt; time spent in the &lt;math&gt;{k - 1}^{th}&lt;/math&gt; calls), giving a total runtime of &lt;math&gt;O(n^2 \lg n)&lt;/math&gt; for &lt;math&gt;n&lt;/math&gt; elements in S.

Note that this cost includes the initial &lt;math&gt;O(n \lg n)&lt;/math&gt; cost for sorting S. Also, this algorithm is always going to be &lt;math&gt;O(n^{k-1} \lg n)&lt;/math&gt; for all &lt;math&gt;k &gt;= 2&lt;/math&gt;. The exercise just states an upper bound.


Back to [[Chapter 4]]</text>
      <sha1>7oekb9j4tf4bhxszpd5bhde2lcd6dqh</sha1>
    </revision>
  </page>
  <page>
    <title>5.1</title>
    <ns>0</ns>
    <id>142</id>
    <revision>
      <id>334</id>
      <timestamp>2020-09-21T00:53:44Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "'''Part -1''' Since set is sorted the max element will lie at position  &lt;pre&gt; Since set is sorted the max element will lie at position      Max = Set[k] where k != 0     Set[n..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="888">'''Part -1''' Since set is sorted the max element will lie at position 
&lt;pre&gt;
Since set is sorted the max element will lie at position 
    Max = Set[k] where k != 0
    Set[n] where K == n
&lt;/pre&gt;

'''Part -2 ''' Apply binary search to find out transition point
&lt;pre&gt;
Assume set indexes are zero based
FindNumberOfRotations(A):
    1. if  (A[0] &lt; A[n-1]) then
        There is no rotation made return 0
    2. low =  0, high =1
    3. mid = (low + high)/2
    4. if(A[mid] &lt; A[high]) then
            Transition lies in left half of the array
            if A[mid-1] &gt; A[mid] then return mid
            else
                high = mid-1
                Go to step 3.
        else
            Transition lies in right half of array
            if(A[mid] &gt; A[mid+1]) then return mid+1
            else
                low = mid+1
                Go to step 3
&lt;/pre&gt;


Back to [[Chapter 5]]</text>
      <sha1>nm3f9qrdiwyjkajjuzm7vhutybssicf</sha1>
    </revision>
  </page>
  <page>
    <title>5.11</title>
    <ns>0</ns>
    <id>147</id>
    <revision>
      <id>339</id>
      <timestamp>2020-09-21T00:56:50Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 5]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 5]]</text>
      <sha1>6ays171rrh6j7diyzgln0mpzn0mat0b</sha1>
    </revision>
  </page>
  <page>
    <title>5.13</title>
    <ns>0</ns>
    <id>148</id>
    <revision>
      <id>340</id>
      <timestamp>2020-09-21T00:56:54Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 5]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 5]]</text>
      <sha1>6ays171rrh6j7diyzgln0mpzn0mat0b</sha1>
    </revision>
  </page>
  <page>
    <title>5.15</title>
    <ns>0</ns>
    <id>149</id>
    <revision>
      <id>341</id>
      <timestamp>2020-09-21T00:56:58Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 5]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 5]]</text>
      <sha1>6ays171rrh6j7diyzgln0mpzn0mat0b</sha1>
    </revision>
  </page>
  <page>
    <title>5.3</title>
    <ns>0</ns>
    <id>143</id>
    <revision>
      <id>335</id>
      <timestamp>2020-09-21T00:54:40Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "(1) Do a binary search within the range of &lt;math&gt;1-n&lt;/math&gt;. You guess the right number within O(log n) questions.  (2) If you don't know n start with a random number &lt;math&gt;2^..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="391">(1) Do a binary search within the range of &lt;math&gt;1-n&lt;/math&gt;. You guess the right number within O(log n) questions.

(2) If you don't know n start with a random number &lt;math&gt;2^i&lt;/math&gt; and if it is larger than the number you are looking for do a binary search within &lt;math&gt;1-2^i&lt;/math&gt; as in (1). If &lt;math&gt;2^i&lt;/math&gt; is less then guess &lt;math&gt;2^{i+1}&lt;/math&gt; and repeat.


Back to [[Chapter 5]]</text>
      <sha1>0o07gx1cv2bi0yoyolb2udpsuakzb8x</sha1>
    </revision>
  </page>
  <page>
    <title>5.5</title>
    <ns>0</ns>
    <id>144</id>
    <revision>
      <id>336</id>
      <timestamp>2020-09-21T00:55:41Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Apply binary search to find out transition point &lt;pre&gt; Assume set indexes are zero based FindIndex(A):     1. low =  0, high =1     2. mid = (low + high)/2     3. if(A[mid] &gt;..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="520">Apply binary search to find out transition point
&lt;pre&gt;
Assume set indexes are zero based
FindIndex(A):
    1. low =  0, high =1
    2. mid = (low + high)/2
    3. if(A[mid] &gt; mid) then
            Index will lie in left half of the array
                high = mid-1
                Go to step 2.
        else if (A[mid] &lt; mid) then
            Index will lie in right half of array
            low = mid + 1
        else
            return mid
&lt;/pre&gt;
--[[User:Max|Max]] 07:31, 25 June 2010 (EDT)


Back to [[Chapter 5]]</text>
      <sha1>ezeu3skphnpsxbn88k6y4vuteyaph90</sha1>
    </revision>
  </page>
  <page>
    <title>5.7</title>
    <ns>0</ns>
    <id>145</id>
    <revision>
      <id>337</id>
      <timestamp>2020-09-21T00:56:23Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "&lt;math&gt;O(n+m)&lt;/math&gt; is necessary and sufficient. Lower bound comes from potentially independent values along second diagonal -- upper bound comes from observing that we can el..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="729">&lt;math&gt;O(n+m)&lt;/math&gt; is necessary and sufficient.
Lower bound comes from potentially independent values along second diagonal --
upper bound comes from observing that we can eliminate either a row or a
column in each comparison if we start from the lower left corner and walk
up or left.

Having M[0..n-1][0..m-1] and a struct Point {int x, int y}, we could have the following solution:


    Point* findPosition(int key) {
      int row = 0, col = m-1;
      while (row &lt; n &amp;&amp; col &gt;= 0) {
         if (M[row][col] == key) {
            return new Point(row,col);         
         }
         else if (M[row][col] &gt; key) {
            col--;
         }
         else row++; 
      }
      return NULL;
    }

Back to [[Chapter 5]]</text>
      <sha1>16si46r8on6o4xm8ob8biz6eudzoxx0</sha1>
    </revision>
  </page>
  <page>
    <title>5.9</title>
    <ns>0</ns>
    <id>146</id>
    <revision>
      <id>338</id>
      <timestamp>2020-09-21T00:56:46Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 5]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 5]]</text>
      <sha1>6ays171rrh6j7diyzgln0mpzn0mat0b</sha1>
    </revision>
  </page>
  <page>
    <title>6.1</title>
    <ns>0</ns>
    <id>151</id>
    <revision>
      <id>343</id>
      <timestamp>2020-09-21T00:58:37Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 6]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 6]]</text>
      <sha1>3smewfo0xwsuhuwmsly71vlkiy8lx9w</sha1>
    </revision>
  </page>
  <page>
    <title>6.11</title>
    <ns>0</ns>
    <id>155</id>
    <revision>
      <id>347</id>
      <timestamp>2020-09-21T00:58:52Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 6]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 6]]</text>
      <sha1>3smewfo0xwsuhuwmsly71vlkiy8lx9w</sha1>
    </revision>
  </page>
  <page>
    <title>6.3</title>
    <ns>0</ns>
    <id>150</id>
    <revision>
      <id>342</id>
      <timestamp>2020-09-21T00:57:54Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "1) Starting from left to right, the number of inversions   for 1st number is n-1   for 2nd number is n-2   ...   ..   ....nth number is n-n = 0  Total number of inversions is..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1666">1) Starting from left to right, the number of inversions
  for 1st number is n-1
  for 2nd number is n-2
  ...
  ..
  ....nth number is n-n = 0

Total number of inversions is the sum of all of the above 
sum of integers from 0 to n - 1 = n(n-1)/2

2. We know that the maximum num of inversions is n(n-1)/2.
  Consider a permutation P.
  a1 a2 ai..ak...aj..am.... an-1 an

  ai and aj are out of order
  ak and am are in order.  
  For Pr,
  ai and aj will get reversed, and will become in order.
  ak and am will get reversed and will become out of order.

  Every In order pair becomes an inversion.
  And every inversion becomes corrected.
   
If P contains "x" inversions.. then it also contained "n(n-1)/2 - x" in order pairs.
Thus Pr contains "x" in order pairs and "n(n-1)/2 - x" inversions.

Summing up the inversions in P and Pr we get n(n-1)/2

3. To calculate the max inversions in part 1, 
every ith position had n - i inversions.
i.e following a number, all other numbers will be out of order.
In the average case, we can argue that about 1/2 of the number will be
out of order....

  for 1st number  (n-1)/2
  for 2nd number   (n-2)/2
  ...
  ..
  ....nth number is (n-n)/2 = 0

Total number of inversions is the sum of all of the above 
sum of integers from 0 to (n - 1)/2 = n(n-1)/4...

'''Alternative solution to 3:''' Any permutation of any set is equally likely. Previous result shows that every permutation has its reversal. If we put pair up every permutation of a set with its reversal, they combine to n(n-1)/2 inversions. There are half as much pairs as there are permutations so the result is n(n-1)/2 * 1/2 = n(n-1)/4


Back to [[Chapter 6]]</text>
      <sha1>h40c1kpbhomnitnfdugog8oybhgen1v</sha1>
    </revision>
  </page>
  <page>
    <title>6.5</title>
    <ns>0</ns>
    <id>152</id>
    <revision>
      <id>344</id>
      <timestamp>2020-09-21T00:58:41Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 6]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 6]]</text>
      <sha1>3smewfo0xwsuhuwmsly71vlkiy8lx9w</sha1>
    </revision>
  </page>
  <page>
    <title>6.7</title>
    <ns>0</ns>
    <id>153</id>
    <revision>
      <id>345</id>
      <timestamp>2020-09-21T00:58:45Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 6]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 6]]</text>
      <sha1>3smewfo0xwsuhuwmsly71vlkiy8lx9w</sha1>
    </revision>
  </page>
  <page>
    <title>6.9</title>
    <ns>0</ns>
    <id>154</id>
    <revision>
      <id>346</id>
      <timestamp>2020-09-21T00:58:48Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 6]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 6]]</text>
      <sha1>3smewfo0xwsuhuwmsly71vlkiy8lx9w</sha1>
    </revision>
  </page>
  <page>
    <title>7.1</title>
    <ns>0</ns>
    <id>156</id>
    <revision>
      <id>348</id>
      <timestamp>2020-09-21T00:59:55Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "(a) BFS: * Graph G1: A, B, D, I, C, E, G, J, F, H * Graph G2: A, B, E, C, F, I, D, G, J, M, H, K, N, L, O, P  (b) DFS: * Graph G1: A, B, C, E, D, G, H, F, J, I * Graph G2: A,..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="241">(a) BFS:
* Graph G1: A, B, D, I, C, E, G, J, F, H
* Graph G2: A, B, E, C, F, I, D, G, J, M, H, K, N, L, O, P

(b) DFS:
* Graph G1: A, B, C, E, D, G, H, F, J, I
* Graph G2: A, B, C, D, H, G, F, E, I, J, K, L, P, O, N, M

Back to [[Chapter 7]]</text>
      <sha1>tnu06cp6irqzypqev2yicvzk7rfga4y</sha1>
    </revision>
  </page>
  <page>
    <title>7.11</title>
    <ns>0</ns>
    <id>161</id>
    <revision>
      <id>353</id>
      <timestamp>2020-09-21T01:02:54Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 7]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 7]]</text>
      <sha1>s5l6idekc362rbphybb56n4hiiy2xgd</sha1>
    </revision>
  </page>
  <page>
    <title>7.13</title>
    <ns>0</ns>
    <id>162</id>
    <revision>
      <id>354</id>
      <timestamp>2020-09-21T01:03:09Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 7]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 7]]</text>
      <sha1>s5l6idekc362rbphybb56n4hiiy2xgd</sha1>
    </revision>
  </page>
  <page>
    <title>7.15</title>
    <ns>0</ns>
    <id>163</id>
    <revision>
      <id>355</id>
      <timestamp>2020-09-21T01:03:13Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 7]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 7]]</text>
      <sha1>s5l6idekc362rbphybb56n4hiiy2xgd</sha1>
    </revision>
  </page>
  <page>
    <title>7.17</title>
    <ns>0</ns>
    <id>164</id>
    <revision>
      <id>356</id>
      <timestamp>2020-09-21T01:04:21Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "1) We can determine that leafs should never be included into the cover. Therefore all leaves should be unmarked, which means that all of their parents should be marked. Now we..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1498">1) We can determine that leafs should never be included into the cover. Therefore all leaves should be unmarked, which means that all of their parents should be marked. Now we remove all leaves from the tree and all of their parents, together with all of their edges. We then repeat this process on the modified tree.

2) We consider again the leafs, each is degree 1. For each leaf, if we consider its parent, its degree is the number of children + 1. It means that we have to choose between removing the n children of degree one or the parent of degree n+1. We remove the parent, mark the leafs as included, and recurse as in 1) above.

3) We know we will be able to remove at most one every other node, so we use a two-coloring technique (Red/Black) and perform a post-order traversal. Let's assume we will remove all the Black node.  When we process a node, we also store with each node the sum over its immediate children of the respective Red and Black weight for the subtree.
If not all of the children are Red, we need to mark the current node as Red. But we also have the option to reverse the coloring of all the Red-children's subtree. So we look at the sum over the red-children for 
Red and Black, and compare the difference of these sum to the current node's weight. If the current node's weight is above, we swap the coloring for these subtree.
The current node will record the Black and Red sum of its children's subtree, and add its own weight to its color.


Back to [[Chapter 7]]</text>
      <sha1>jf0317z2hjzbdvxc671dkfviz3e3uke</sha1>
    </revision>
  </page>
  <page>
    <title>7.19</title>
    <ns>0</ns>
    <id>165</id>
    <revision>
      <id>357</id>
      <timestamp>2020-09-21T01:05:34Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "# This translates to the question of labeling the tree with two colors, because this way each edge's vertices are colored differently. The larger group of colors is the sought..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="232"># This translates to the question of labeling the tree with two colors, because this way each edge's vertices are colored differently. The larger group of colors is the sought for maximum-size independent set.

Back to [[Chapter 7]]</text>
      <sha1>hqm1cnth9qnlpxhker2v1kgi3yo4ekc</sha1>
    </revision>
  </page>
  <page>
    <title>7.21</title>
    <ns>0</ns>
    <id>166</id>
    <revision>
      <id>359</id>
      <timestamp>2020-09-21T01:06:57Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "(a) Compare every possible set of three vertices and test if there is an edge between the three.  (b) One may be tempted to use DFS to find cycle of length 3, by maintaining a..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="2464">(a) Compare every possible set of three vertices and test if there is an edge between the three.

(b) One may be tempted to use DFS to find cycle of length 3, by maintaining an array parent[I] and check any backedge u-v whether grandparent of u is equal to v. However this is incorrect, consider the graph

A - B - C - D - A (square)

D - E - F - G - D (another square, connected to the first one through D)

A - G (edge that closes the triangle A - D - G).


DFS would produce: 

A -&gt; B - &gt; C -&gt; D (grandParent of D is B) -&gt; A (nothing to do, back up the recursion to D and move to the next edge) -&gt; E -&gt; F -&gt; G (grandparent of G is E)

At this point we find a cycle when considering the edge G - D, but the grandparent of D isn't connected to G. So we continue and consider A, and then the recursion ends and we process back every node till A, and consider the last edge: A -G. Since A isn't connected to the grandfather of G, we don't find the triangle.

Some possible solutions can be found in : http :// i11www.iti.uni-karlsruhe.de/extra/publications/sw-fclt-05_t.pdf

----
Alternative solution

&lt;pre&gt;
1. O(|V|^3)
- If only adjacency lists are available, convert adjacency lists to the adjacency matrix
- If an adjacency matrix is available, traverse the matrix O(|V|^2) get a vertex U and an adjacent M, traverse the M row O(|V|) and check the vertices
for adjacency with U O(1)

2. O(|V|*|Е|), |V| &lt;= |E|
- Data preparation
- - Let's analyze the case with the largest upper bound =&gt; assume that |V| = |E|
- - If an adjacency matrix is available, create additional adjacency lists O(|V|^2)
- - If adjacency lists are given, create an additional adjacency matrix O(|V| + |E|) = O(2 * |V|) by assumption ~ O(|V|)
- - At this stage, we have adjacency lists and an adjacency matrix, and each element of the adjacency lists also stores its coordinates from the adjacency matrix

- Algorithm
- - Traverse adjacency lists O(|V| + |E|) vertex U is the owner of the current list, vertex M is a list item
- - - Traversing a list owned by M O(|V|) vertex M is the owner of the list, vertex C is a list item
- - - - Checking C for adjacency with U O(1), since the coordinates of the vertices are known =&gt; row U and column C are known
- - Time complexity O(|V| + |E|) * O(|V|) * O(1) ~ O(|V|) * O(|V|) = O(|V|^2) ~ O(|V| * |E|), by assumption |V| = |E|
&lt;/pre&gt;
--[[User:Bkarpov96|Bkarpov96]] ([[User talk:Bkarpov96|talk]]) 10:16, 5 July 2020 (UTC)


Back to [[Chapter 7]]</text>
      <sha1>d5gs8azouu4ig66jzt3la4ksonafkvz</sha1>
    </revision>
  </page>
  <page>
    <title>7.23</title>
    <ns>0</ns>
    <id>167</id>
    <revision>
      <id>360</id>
      <timestamp>2020-09-21T01:07:57Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with " for any node in the tree, there are two possibilities # either the diameter is contained in one of the subtrees # or the node itself is at the top of the longest path in the..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1381">
for any node in the tree, there are two possibilities
# either the diameter is contained in one of the subtrees
# or the node itself is at the top of the longest path in the tree that defines the diameter

in the second case, the diameter is equal to the sum of depth of the two deepest sub-trees of that node

the following algorithm calculates the diameter in &lt;math&gt;O(n)&lt;/math&gt; time

&lt;source lang="python"&gt;

class Node:

    def __init__(self, value, children):
        self.value = value
        self.children = children

    @classmethod
    def preorder(cls, lists):
        return cls(
                lists[0],
                [cls.preorder(l) for l in lists[1:]]
            )

 
def dd(root):
    """
    returns depth, diameter for tree with given root node

    &gt;&gt;&gt; dd(Node.preorder([0, [1], [2]]))
    (1, 2)
    &gt;&gt;&gt; dd(Node.preorder([1, [2, [3]], [4, [5]]]))
    (2, 4)
    &gt;&gt;&gt; dd(Node.preorder([1, [2, [3, [4]], [5, [6, [7], [8]]]], [9]]))
    (4, 5)
    """
    d1 = d2 = -1
    md = 0
    for child in root.children:
        depth, diameter = dd(child)
        if diameter &gt; md:
            md = diameter
        if depth &gt;= d1:
            d2 = d1
            d1 = depth
        elif depth &gt; d2:
            d2 = depth
    return d1 + 1, max(md, d1 + d2 + 2)


if __name__ == "__main__":
    import doctest
    doctest.testmod()

&lt;/source&gt;


Back to [[Chapter 7]]</text>
      <sha1>3tsdp72cq6vth2doe1jjszc3oy7ksas</sha1>
    </revision>
  </page>
  <page>
    <title>7.25</title>
    <ns>0</ns>
    <id>168</id>
    <revision>
      <id>361</id>
      <timestamp>2020-09-21T01:09:22Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Use the BFS starting from the vertex v. For every node keep track of the level from the vertex v. When w is encountered for the first time the level of w is the length of the..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="334">Use the BFS starting from the vertex v. For every node keep track of the level from the vertex v. When w is encountered for the first time the level of w is the length of the shortest path. Count how many times you discover w on that level. Stop expanding nodes when you go past the length of the shortest path.

Back to [[Chapter 7]]</text>
      <sha1>ky4bm9jn6j0cr1etlh4j1ionveu9u21</sha1>
    </revision>
  </page>
  <page>
    <title>7.27</title>
    <ns>0</ns>
    <id>169</id>
    <revision>
      <id>362</id>
      <timestamp>2020-09-21T01:11:10Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 7]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 7]]</text>
      <sha1>s5l6idekc362rbphybb56n4hiiy2xgd</sha1>
    </revision>
  </page>
  <page>
    <title>7.29</title>
    <ns>0</ns>
    <id>170</id>
    <revision>
      <id>363</id>
      <timestamp>2020-09-21T01:11:29Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 7]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 7]]</text>
      <sha1>s5l6idekc362rbphybb56n4hiiy2xgd</sha1>
    </revision>
  </page>
  <page>
    <title>7.3</title>
    <ns>0</ns>
    <id>157</id>
    <revision>
      <id>349</id>
      <timestamp>2020-09-21T01:00:54Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Induction proof:   Base case: Tree composed of just two nodes: x(root) and y. There is only one way x -&gt; y  Assuming there is an unique path between x and y, we add a new leaf..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="325">Induction proof:


Base case: Tree composed of just two nodes: x(root) and y. There is only one way x -&gt; y

Assuming there is an unique path between x and y, we add a new leaf z under y. z is only connected to its parent y, so there is only one way from z to x that is z -&gt; y-&gt;[unique path assumed]-&gt;x


Back to [[Chapter 7]]</text>
      <sha1>rpmqjl3vqyeq7o7hwnymhn57qpi8uva</sha1>
    </revision>
  </page>
  <page>
    <title>7.31</title>
    <ns>0</ns>
    <id>171</id>
    <revision>
      <id>364</id>
      <timestamp>2020-09-21T01:11:38Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 7]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 7]]</text>
      <sha1>s5l6idekc362rbphybb56n4hiiy2xgd</sha1>
    </revision>
  </page>
  <page>
    <title>7.33</title>
    <ns>0</ns>
    <id>172</id>
    <revision>
      <id>365</id>
      <timestamp>2020-09-21T01:11:44Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 7]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 7]]</text>
      <sha1>s5l6idekc362rbphybb56n4hiiy2xgd</sha1>
    </revision>
  </page>
  <page>
    <title>7.35</title>
    <ns>0</ns>
    <id>173</id>
    <revision>
      <id>366</id>
      <timestamp>2020-09-21T01:11:58Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 7]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 7]]</text>
      <sha1>s5l6idekc362rbphybb56n4hiiy2xgd</sha1>
    </revision>
  </page>
  <page>
    <title>7.37</title>
    <ns>0</ns>
    <id>174</id>
    <revision>
      <id>367</id>
      <timestamp>2020-09-21T01:12:33Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Proof by induction.  A tournament with 2 vertices (1,2) has a Hamiltonian path. 1 -&gt; 2 or vice versa  Now suppose our tournament with n vertices has a Hamiltonian path 1,..,n...."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="3727">Proof by induction.

A tournament with 2 vertices (1,2) has a Hamiltonian path. 1 -&gt; 2 or vice versa

Now suppose our tournament with n vertices has a Hamiltonian path 1,..,n. Now add a vertex (n+1) that is connected to every other node. 3 cases may occur:

case1) If the first node of the n Hamiltonian path can be reached by vertex (n+1), add (n+1) to the beginning of the path. New Hamiltonian path: n+1,1,...,n

case2) If the last node of the n Hamiltonian path can reach the vertex (n+1), add (n+1) to the end of the path. New Hamiltonian path: 1,...,n,n+1

case3) Take the first node of the n Hamiltonian path that can be reached by (n+1). This must exist, because we are not in case 2. Call this node k. By definition of this node, (k-1) can reach (n+1). Form the new Hamiltonian path as: 1,...,k-1,n+1,k,...,n.

----
&lt;pre&gt;
II. Algorithm O(n^2)
H = []  # Hamiltonian path
Create a queue Q from all the vertices of the tournament, the order of the vertices in the queue does not matter
Cycle until the queue is empty:
- Extract vertex V0 from the queue
- If H is empty, add V0 to H, continue
- Find the vertex Vi in H: ∃ V0-&gt;Vi, where i is the minimum index  # O(n)
- If Vi was not found V0-&gt;Vi does not exist, then insert V0 at the end of H  # O(1). All edges of V0 incoming
- Otherwise, if Vi was found V0-&gt;Vi exists, then inserting V0 in H before Vi  # O(n)

III. Algorithm O(n*logn)
1. Initializing the adjacency matrix A  # The time complexity of initialization is O (n^2) in any case, since the graph is complete =&gt; processing n*(n-1)/2 edges
- The matrix is initialized with n arrays of n elements. After adding arrays, assign 0 to all elements on the main diagonal  # Graph without loops
2. Data preparation
- Mentally change the complete undirected graph with the complete strongly connected directed graph
- Eliminating strong connectivity - for each pair (V, W), remove 1 of the edges A[V][W] = 0 or A[W][V] = 0
3. Finding the Hamiltonian path
- If A[s_i][s_j] == 1, there is an edge s_i-&gt;s_j =&gt; s_i dominates s_j =&gt; s_i &gt; s_j
- As it is possible to establish a relationship between the vertices, it is possible to sort them out  # O(n*logn)
&lt;/pre&gt;
&lt;source lang="python"&gt;
""" O(n*logn) implementation """

from random import randint
from functools import cmp_to_key
from time import perf_counter

for m in range(100):
    cap = 12
    size = 2 ** cap

    graph = [[1 for i in range(size)] for k in range(size)]  # Adjacency matrix representation

    for i in range(size):  # Building 1 big tournament
        for j in range(i, size):
            if randint(0, 1) or j == i:  # Setting directions and removing loops
                graph[i][j] = 0  # Removing i -&gt; j
            else:
                graph[j][i] = 0  # Removing j -&gt; i

    for i in range(size):  # Tournament correctness check
        for j in range(size):
            if i != j:
                assert graph[i][j] != graph[j][i]
            else:
                assert graph[i][j] == 0

    for z in range(2, cap + 1):  # Finding Hamiltonian paths for subgraphs
        subgraph_size = 2 ** z
        start_time = perf_counter()
        hamiltonian_path = sorted(range(subgraph_size), key=cmp_to_key(lambda a, b: graph[b][a] - graph[a][b]))
        # print(hamiltonian_path, end='\n\n')  # Output path
        print('Time: {:f}s | Size: {:d}'.format(perf_counter() - start_time, subgraph_size))

        for i in range(subgraph_size - 1):  # Hamiltonian path check
            assert graph[hamiltonian_path[i]][hamiltonian_path[i + 1]]  # Next vertex in path must be reachable

    print('')  # New line between cases
&lt;/source&gt;--[[User:Bkarpov96|Bkarpov96]] ([[User talk:Bkarpov96|talk]]) 17:34, 8 July 2020 (UTC)


Back to [[Chapter 7]]</text>
      <sha1>cg5yvt4qkfrz8d40az977p3u1m4g7ew</sha1>
    </revision>
  </page>
  <page>
    <title>7.39</title>
    <ns>0</ns>
    <id>175</id>
    <revision>
      <id>368</id>
      <timestamp>2020-09-21T01:13:08Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 7]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 7]]</text>
      <sha1>s5l6idekc362rbphybb56n4hiiy2xgd</sha1>
    </revision>
  </page>
  <page>
    <title>7.41</title>
    <ns>0</ns>
    <id>176</id>
    <revision>
      <id>369</id>
      <timestamp>2020-09-21T01:13:23Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 7]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 7]]</text>
      <sha1>s5l6idekc362rbphybb56n4hiiy2xgd</sha1>
    </revision>
  </page>
  <page>
    <title>7.43</title>
    <ns>0</ns>
    <id>177</id>
    <revision>
      <id>370</id>
      <timestamp>2020-09-21T01:13:37Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 7]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 7]]</text>
      <sha1>s5l6idekc362rbphybb56n4hiiy2xgd</sha1>
    </revision>
  </page>
  <page>
    <title>7.5</title>
    <ns>0</ns>
    <id>158</id>
    <revision>
      <id>350</id>
      <timestamp>2020-09-21T01:01:23Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Graphs with max degree 2, can be bipartite (even number of edges) or tripartite (odd number of edges)  -----  Consider a triangle (3 edges, 3 vertices): it's not bipartite eve..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1169">Graphs with max degree 2, can be bipartite (even number of edges) or tripartite (odd number of edges)

-----

Consider a triangle (3 edges, 3 vertices): it's not bipartite even though every node has an even number of edges and the graph has an even number of edges.


-----

For such a graph, such that the degree of every vertex is at most 2, we can use 
a DFS traversal, coloring the child the opposite color of the parent.
When we see a Back edge, we color the currently discovered child with a
color different that the parent, and also different from the ancestor 
discovered through that back edge.

Since there is just one traversal, it runs in O(m + n) (m edges, n vertices)

-----

Another Solution:

A graph whose each vertex has degree at most K has chromatic number less than equal to K + 1.

It is given that each degree has vertex at most 2, therefore determine whether the graph is two colourable or not with the help of BFS traversal. If it is then the answer is 2 otherwise the answer is 3. If graph has only one vertex then the answer will be 1.

Let me know whether the solution is right? (sah.sslpu@gmail.com) BTW it is right!


Back to [[Chapter 7]]</text>
      <sha1>axf9t7yj57b02pl0gqtbgkvwpumh2z0</sha1>
    </revision>
  </page>
  <page>
    <title>7.7</title>
    <ns>0</ns>
    <id>159</id>
    <revision>
      <id>351</id>
      <timestamp>2020-09-21T01:01:54Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 7]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 7]]</text>
      <sha1>s5l6idekc362rbphybb56n4hiiy2xgd</sha1>
    </revision>
  </page>
  <page>
    <title>7.9</title>
    <ns>0</ns>
    <id>160</id>
    <revision>
      <id>352</id>
      <timestamp>2020-09-21T01:02:23Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 7]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 7]]</text>
      <sha1>s5l6idekc362rbphybb56n4hiiy2xgd</sha1>
    </revision>
  </page>
  <page>
    <title>8.1</title>
    <ns>0</ns>
    <id>217</id>
    <revision>
      <id>416</id>
      <timestamp>2020-09-21T14:04:53Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 8]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 8]]</text>
      <sha1>1k2i0d9t4l0y0juueyn6wqefjdbm3l3</sha1>
    </revision>
  </page>
  <page>
    <title>8.11</title>
    <ns>0</ns>
    <id>222</id>
    <revision>
      <id>421</id>
      <timestamp>2020-09-21T14:07:33Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 8]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 8]]</text>
      <sha1>1k2i0d9t4l0y0juueyn6wqefjdbm3l3</sha1>
    </revision>
  </page>
  <page>
    <title>8.13</title>
    <ns>0</ns>
    <id>223</id>
    <revision>
      <id>422</id>
      <timestamp>2020-09-21T14:07:54Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 8]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 8]]</text>
      <sha1>1k2i0d9t4l0y0juueyn6wqefjdbm3l3</sha1>
    </revision>
  </page>
  <page>
    <title>8.15</title>
    <ns>0</ns>
    <id>224</id>
    <revision>
      <id>424</id>
      <timestamp>2020-09-21T14:09:09Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 8]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 8]]</text>
      <sha1>1k2i0d9t4l0y0juueyn6wqefjdbm3l3</sha1>
    </revision>
  </page>
  <page>
    <title>8.17</title>
    <ns>0</ns>
    <id>225</id>
    <revision>
      <id>425</id>
      <timestamp>2020-09-21T14:09:33Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 8]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 8]]</text>
      <sha1>1k2i0d9t4l0y0juueyn6wqefjdbm3l3</sha1>
    </revision>
  </page>
  <page>
    <title>8.19</title>
    <ns>0</ns>
    <id>226</id>
    <revision>
      <id>426</id>
      <timestamp>2020-09-21T14:09:39Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 8]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 8]]</text>
      <sha1>1k2i0d9t4l0y0juueyn6wqefjdbm3l3</sha1>
    </revision>
  </page>
  <page>
    <title>8.21</title>
    <ns>0</ns>
    <id>227</id>
    <revision>
      <id>427</id>
      <timestamp>2020-09-21T14:09:46Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 8]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 8]]</text>
      <sha1>1k2i0d9t4l0y0juueyn6wqefjdbm3l3</sha1>
    </revision>
  </page>
  <page>
    <title>8.23</title>
    <ns>0</ns>
    <id>228</id>
    <revision>
      <id>429</id>
      <timestamp>2020-09-21T14:10:45Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 8]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 8]]</text>
      <sha1>1k2i0d9t4l0y0juueyn6wqefjdbm3l3</sha1>
    </revision>
  </page>
  <page>
    <title>8.25</title>
    <ns>0</ns>
    <id>229</id>
    <revision>
      <id>430</id>
      <timestamp>2020-09-21T14:11:39Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Step 1:  Perform topological sorting of the graph (we can do it as Graph is acyclic). This is O(n + m)  Step 2:  Go through vertices in topological order. Initially all vertic..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="561">Step 1:

Perform topological sorting of the graph (we can do it as Graph is acyclic). This is O(n + m)

Step 2:

Go through vertices in topological order. Initially all vertices marked as inaccessible and only starting vertex marked with 0 distance.
For every vertex in cycle, if it is accessible, we update all its children with new distance if new distance is shorter then previous one.
Topological sorting ensures that we don't ever need to go backtrack. This is O(n + m).

Total running bound is O(n+m), which is linear as requested.


Back to [[Chapter 8]]</text>
      <sha1>720e2ybh4i9p8speonwqg3shlaae6vp</sha1>
    </revision>
  </page>
  <page>
    <title>8.27</title>
    <ns>0</ns>
    <id>230</id>
    <revision>
      <id>431</id>
      <timestamp>2020-09-21T14:12:11Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "The problem reduces to Floyd - Warshall algorithm if you take logs of all currency-exchange rates, as if a * b = c then ln(a) + ln(b) = ln(c).  In computational finance people..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="438">The problem reduces to Floyd - Warshall algorithm if you take logs of all currency-exchange rates, as if a * b = c then ln(a) + ln(b) = ln(c).

In computational finance people often use logarithms of prices instead of prices themselves, as it gives faster calculations and makes it easy to apply log-normal distribution instead of normal distribution (log-normal distribution is more appropriate for asset prices).


Back to [[Chapter 8]]</text>
      <sha1>kqd17clsit2owwobrvp52sh6axreml2</sha1>
    </revision>
  </page>
  <page>
    <title>8.29</title>
    <ns>0</ns>
    <id>231</id>
    <revision>
      <id>432</id>
      <timestamp>2020-09-21T14:12:28Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "1. Find maximum matching. Bipartite matching is described in the book. General matching would require Edmonds Blossom algorithm. 2. Include an arbitrary edge for every uncover..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="238">1. Find maximum matching. Bipartite matching is described in the book. General matching would require Edmonds Blossom algorithm.
2. Include an arbitrary edge for every uncovered vertex. A greedy algorithm suffices.


Back to [[Chapter 8]]</text>
      <sha1>euo91gegfhhrrtaqgihqbas8gyhoakq</sha1>
    </revision>
  </page>
  <page>
    <title>8.3</title>
    <ns>0</ns>
    <id>218</id>
    <revision>
      <id>417</id>
      <timestamp>2020-09-21T14:06:03Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "No. Counter example provided below:  G(V,E,W) = ((A,B,C,D),({A,B},{B,C},{C,D},{D,A}),(1,2,3,4))  Minimum spanning tree has a weight of 6 with edges {A,B},{B,C},{C,D}.  In the..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="252">No. Counter example provided below:

G(V,E,W) = ((A,B,C,D),({A,B},{B,C},{C,D},{D,A}),(1,2,3,4))

Minimum spanning tree has a weight of 6 with edges {A,B},{B,C},{C,D}.

In the full graph the minimum distance between A and D is 4.


Back to [[Chapter 8]]</text>
      <sha1>rhxr6f095j8e7adw5z3qsckfmwnli6f</sha1>
    </revision>
  </page>
  <page>
    <title>8.5</title>
    <ns>0</ns>
    <id>219</id>
    <revision>
      <id>418</id>
      <timestamp>2020-09-21T14:06:45Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "In both algorithms, an edge can only ever be picked once, so they will both eventually terminate regardless of negative edge weights.  I also suspect that they still generate..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="252">In both algorithms, an edge can only ever be picked once, so they will both eventually terminate regardless of negative edge weights.  I also suspect that they still generate minimum spanning trees, but don't have a proof of it.


Back to [[Chapter 8]]</text>
      <sha1>5r9gp246ab3nda0tjybt1jfi774s57q</sha1>
    </revision>
  </page>
  <page>
    <title>8.7</title>
    <ns>0</ns>
    <id>220</id>
    <revision>
      <id>419</id>
      <timestamp>2020-09-21T14:07:10Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 8]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 8]]</text>
      <sha1>1k2i0d9t4l0y0juueyn6wqefjdbm3l3</sha1>
    </revision>
  </page>
  <page>
    <title>8.9</title>
    <ns>0</ns>
    <id>221</id>
    <revision>
      <id>420</id>
      <timestamp>2020-09-21T14:07:25Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 8]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 8]]</text>
      <sha1>1k2i0d9t4l0y0juueyn6wqefjdbm3l3</sha1>
    </revision>
  </page>
  <page>
    <title>9.1</title>
    <ns>0</ns>
    <id>200</id>
    <revision>
      <id>398</id>
      <timestamp>2020-09-21T13:51:36Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "== Algorithm ==  Given &lt;code&gt;a&lt;/code&gt;, the input array, and &lt;code&gt;curr&lt;/code&gt;, the derangement built up so far:  # If &lt;code&gt;curr&lt;/code&gt; represents a complete solution, print i..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1837">== Algorithm ==

Given &lt;code&gt;a&lt;/code&gt;, the input array, and &lt;code&gt;curr&lt;/code&gt;, the derangement built up so far:

# If &lt;code&gt;curr&lt;/code&gt; represents a complete solution, print it.
# Otherwise, examine all the possibilities for the next element of the derangement. The next element must come from the input array &lt;code&gt;a&lt;/code&gt;. It must not already have been used so far (&lt;code&gt;!curr.contains(a[i]&lt;/code&gt;), and it must not be the element at the same position in the input array (&lt;code&gt;i != curr.size()&lt;/code&gt;).
## For each remaining possibility, add it to the current derangement and recurse.

== Implementation in Java ==

&lt;pre&gt;
public class DerangementGenerator {
    public void derangements(int[] a) {
        d(a, new LinkedList&lt;Integer&gt;());
    }

    public void d(int[] a, LinkedList&lt;Integer&gt; curr) {
        if (curr.size() == a.length)
            print(curr);
        else {
            for (int i = 0; i &lt; a.length; i++) {
                if (!curr.contains(a[i]) &amp;&amp; i != curr.size()) {
                    curr.addLast(a[i]); // O(1)
                    d(a, curr);
                    curr.removeLast(); // O(1)
                }
            }
        }
    }

    public void print(List&lt;Integer&gt; l) {
        for (int i = 0; i &lt; l.size() - 1; i++) {
            System.out.print(l.get(i) + ", ");
        }
        System.out.println(l.get(l.size() - 1));
    }

    public static void main(String[] args) {
        if (args.length &lt; 1) {
            System.err.println("Usage: java DerangementGenerator N");
            System.exit(-1);
        }
        int n = Integer.parseInt(args[0]);

        DerangementGenerator dg = new DerangementGenerator();
        int[] a = new int[n];
        for (int i = 0; i &lt; n; i++) {
            a[i] = i + 1;
        }

        dg.derangements(a);
    }
}
&lt;/pre&gt;


Back to [[Chapter 9]]</text>
      <sha1>qpa5gnt9ssx92t8y6lworjthk0jhrfa</sha1>
    </revision>
  </page>
  <page>
    <title>9.11</title>
    <ns>0</ns>
    <id>205</id>
    <revision>
      <id>403</id>
      <timestamp>2020-09-21T14:00:01Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 9]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 9]]</text>
      <sha1>29jgjx891rt4xsv8lebh6ffwjn0pcim</sha1>
    </revision>
  </page>
  <page>
    <title>9.13</title>
    <ns>0</ns>
    <id>206</id>
    <revision>
      <id>404</id>
      <timestamp>2020-09-21T14:00:10Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 9]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 9]]</text>
      <sha1>29jgjx891rt4xsv8lebh6ffwjn0pcim</sha1>
    </revision>
  </page>
  <page>
    <title>9.15</title>
    <ns>0</ns>
    <id>207</id>
    <revision>
      <id>405</id>
      <timestamp>2020-09-21T14:00:22Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 9]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 9]]</text>
      <sha1>29jgjx891rt4xsv8lebh6ffwjn0pcim</sha1>
    </revision>
  </page>
  <page>
    <title>9.17</title>
    <ns>0</ns>
    <id>208</id>
    <revision>
      <id>406</id>
      <timestamp>2020-09-21T14:00:40Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 9]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 9]]</text>
      <sha1>29jgjx891rt4xsv8lebh6ffwjn0pcim</sha1>
    </revision>
  </page>
  <page>
    <title>9.19</title>
    <ns>0</ns>
    <id>209</id>
    <revision>
      <id>407</id>
      <timestamp>2020-09-21T14:00:44Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 9]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 9]]</text>
      <sha1>29jgjx891rt4xsv8lebh6ffwjn0pcim</sha1>
    </revision>
  </page>
  <page>
    <title>9.21</title>
    <ns>0</ns>
    <id>210</id>
    <revision>
      <id>409</id>
      <timestamp>2020-09-21T14:01:43Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 9]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 9]]</text>
      <sha1>29jgjx891rt4xsv8lebh6ffwjn0pcim</sha1>
    </revision>
  </page>
  <page>
    <title>9.23</title>
    <ns>0</ns>
    <id>211</id>
    <revision>
      <id>410</id>
      <timestamp>2020-09-21T14:01:48Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 9]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 9]]</text>
      <sha1>29jgjx891rt4xsv8lebh6ffwjn0pcim</sha1>
    </revision>
  </page>
  <page>
    <title>9.25</title>
    <ns>0</ns>
    <id>212</id>
    <revision>
      <id>411</id>
      <timestamp>2020-09-21T14:01:51Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 9]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 9]]</text>
      <sha1>29jgjx891rt4xsv8lebh6ffwjn0pcim</sha1>
    </revision>
  </page>
  <page>
    <title>9.27</title>
    <ns>0</ns>
    <id>213</id>
    <revision>
      <id>412</id>
      <timestamp>2020-09-21T14:01:55Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 9]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 9]]</text>
      <sha1>29jgjx891rt4xsv8lebh6ffwjn0pcim</sha1>
    </revision>
  </page>
  <page>
    <title>9.29</title>
    <ns>0</ns>
    <id>214</id>
    <revision>
      <id>413</id>
      <timestamp>2020-09-21T14:02:31Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 9]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 9]]</text>
      <sha1>29jgjx891rt4xsv8lebh6ffwjn0pcim</sha1>
    </revision>
  </page>
  <page>
    <title>9.3</title>
    <ns>0</ns>
    <id>201</id>
    <revision>
      <id>399</id>
      <timestamp>2020-09-21T13:51:55Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 9]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 9]]</text>
      <sha1>29jgjx891rt4xsv8lebh6ffwjn0pcim</sha1>
    </revision>
  </page>
  <page>
    <title>9.31</title>
    <ns>0</ns>
    <id>215</id>
    <revision>
      <id>414</id>
      <timestamp>2020-09-21T14:02:38Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 9]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 9]]</text>
      <sha1>29jgjx891rt4xsv8lebh6ffwjn0pcim</sha1>
    </revision>
  </page>
  <page>
    <title>9.33</title>
    <ns>0</ns>
    <id>216</id>
    <revision>
      <id>415</id>
      <timestamp>2020-09-21T14:02:54Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "We avoid sums and products and throw away parts of the sample space we don't need. At the same time, we want to be efficient in our use of the space.  Conceptually we create a..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="2114">We avoid sums and products and throw away parts of the sample space we don't need. At the same time, we want to be efficient in our use of the space.

Conceptually we create a simple tree branching four ways on the first draw from &lt;code&gt;rng04&lt;/code&gt; (throwing away one value) and then drawing two possible values (say low or high) from the second draw (throwing away one value). Each end point is equally likely and draws are independent so this would provide a uniform sample.

&lt;pre&gt;
#!/usr/bin/env python

import sys, random

def rng04():
    return random.randint(0,4)

# filtered call to rng04
# return 0 1 2 3
def rng03():
    while True:
        i = rng04()
        if i &lt; 4:
            return i

# filtered call to rng04
# return 0 1
# use rng04 instead of rng03 to make analysis easier
def rng01():
    while True:
        i = rng04()
        if i &lt; 4:
            return i % 2

# generate uniform numbers in 0 1 2 3 4 5 6 7
def rng07():
    i = rng03()
    j = rng01()
    return i * 2 + j

if __name__ == "__main__":
    for i in range(10000):
        print rng07()
    sys.exit()
&lt;/pre&gt;

Notice we're not &lt;i&gt;summing&lt;/i&gt; we are indexing uniformly on the filtered values. Summing can skew the distribution away from uniform when it generates more than one way to create a specific value or a differing number than for all other values (e.g. rolling two six sided dice, etc.)

Second part of question asks for &lt;i&gt;expected&lt;/i&gt; of calls to &lt;code&gt;rng04&lt;/code&gt;. The expected number of calls to &lt;code&gt;rng04&lt;/code&gt; if we are filtering calls to &lt;code&gt;rng04&lt;/code&gt; is &lt;math&gt;1/p&lt;/math&gt; where &lt;math&gt;p&lt;/math&gt; is the probability of accepting a value. For both of the filtered calls we are throwing away one of the five values so the &lt;math&gt;p = 0.8&lt;/math&gt; and the expected number of calls is &lt;math&gt;1.25&lt;/math&gt;.

We are making two filtered calls to &lt;code&gt;rng04&lt;/code&gt; in &lt;code&gt;rng07&lt;/code&gt; -- since the &lt;i&gt;expected&lt;/i&gt; value of a sum is just the sum of the expected values we know that each call to &lt;code&gt;rng07&lt;/code&gt; has an the expected number of calls to &lt;code&gt;rng04&lt;/code&gt; of &lt;math&gt;2.5&lt;/math&gt;.


Back to [[Chapter 9]]</text>
      <sha1>3tx674i5mv9iiy7bbcpek3sizr0s9ak</sha1>
    </revision>
  </page>
  <page>
    <title>9.5</title>
    <ns>0</ns>
    <id>202</id>
    <revision>
      <id>400</id>
      <timestamp>2020-09-21T13:52:01Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 9]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 9]]</text>
      <sha1>29jgjx891rt4xsv8lebh6ffwjn0pcim</sha1>
    </revision>
  </page>
  <page>
    <title>9.7</title>
    <ns>0</ns>
    <id>203</id>
    <revision>
      <id>401</id>
      <timestamp>2020-09-21T13:52:29Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 9]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 9]]</text>
      <sha1>29jgjx891rt4xsv8lebh6ffwjn0pcim</sha1>
    </revision>
  </page>
  <page>
    <title>9.9</title>
    <ns>0</ns>
    <id>204</id>
    <revision>
      <id>402</id>
      <timestamp>2020-09-21T13:52:42Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "  Back to [[Chapter 9]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23">

Back to [[Chapter 9]]</text>
      <sha1>29jgjx891rt4xsv8lebh6ffwjn0pcim</sha1>
    </revision>
  </page>
  <page>
    <title>Chapter 1</title>
    <ns>0</ns>
    <id>3</id>
    <revision>
      <id>4</id>
      <timestamp>2020-08-23T18:42:07Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Problems  *[[1.1]]  *[[1.2]]  *[[1.3]]  *[[1.4]]  *[[1.5]]  *[[1.6]]  *[[1.7]]  *[[1.8]]  *[[1.9]]  *[[1.10]]  *[[1.11]]  *[[1.12]]  *[[1.13]]  *[[1.14]]  *[[1.15]]  *[[1.16]]..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="417">Problems

*[[1.1]]

*[[1.2]]

*[[1.3]]

*[[1.4]]

*[[1.5]]

*[[1.6]]

*[[1.7]]

*[[1.8]]

*[[1.9]]

*[[1.10]]

*[[1.11]]

*[[1.12]]

*[[1.13]]

*[[1.14]]

*[[1.15]]

*[[1.16]]

*[[1.17]]

*[[1.18]]

*[[1.19]]

*[[1.20]]

*[[1.21]]

*[[1.22]]

*[[1.23]]

*[[1.24]]

*[[1.25]]

*[[1.26]]

*[[1.27]]

*[[1.28]]

*[[1.29]]

*[[1.30]]

*[[1.31]]

*[[1.32]]

*[[1.33]]

*[[1.34]]

*[[1.35]]

*[[1.36]]

*[[1.37]]

*[[1.38]]</text>
      <sha1>lx04jh7nxbefhzv694c3br8bxgtct9a</sha1>
    </revision>
    <revision>
      <id>5</id>
      <parentid>4</parentid>
      <timestamp>2020-08-23T18:43:03Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="450">Problems

*[[1.1]]

*[[1.2]]

*[[1.3]]

*[[1.4]]

*[[1.5]]

*[[1.6]]

*[[1.7]]

*[[1.8]]

*[[1.9]]

*[[1.10]]

*[[1.11]]

*[[1.12]]

*[[1.13]]

*[[1.14]]

*[[1.15]]

*[[1.16]]

*[[1.17]]

*[[1.18]]

*[[1.19]]

*[[1.20]]

*[[1.21]]

*[[1.22]]

*[[1.23]]

*[[1.24]]

*[[1.25]]

*[[1.26]]

*[[1.27]]

*[[1.28]]

*[[1.29]]

*[[1.30]]

*[[1.31]]

*[[1.32]]

*[[1.33]]

*[[1.34]]

*[[1.35]]

*[[1.36]]

*[[1.37]]

*[[1.38]]


Back to [[Problem Solutions]]</text>
      <sha1>pzenyvb890qwu732jcxdblb8me3599r</sha1>
    </revision>
    <revision>
      <id>7</id>
      <parentid>5</parentid>
      <timestamp>2020-08-23T19:20:07Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1631">Problems

:[[1.1]]. Show that ''a'' + ''b'' can be less than ''min(a, b)''.


:1.2. Show that ''a'' × ''b'' can be less than ''min(a, b)''.


:[[1.3]]. Design/draw a road network with two points ''a'' and ''b'' such that the fastest route between ''a'' and ''b'' is not the shortest route.


:1.4. Design/draw a road network with two points ''a'' and ''b'' such that the shortest route between ''a'' and ''b'' is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers ''S'' = {''s1, s2. . . , sn}''}, and a target number ''T'', find a subset of ''S'' that adds up exactly to ''T''. For example, there exists a subset within ''S'' = {1, 2, 5, 9, 10} that adds up to ''T'' = 22 but not ''T'' = 23.

:Find counterexamples to each of the following algorithms for the knapsack problem. That is, give an ''S'' and ''T'' where the algorithm does not find a solution that leaves the knapsack completely full, even though a full-knapsack solution exists.

::(a) Put the elements of ''S'' in the knapsack in left to right order if they fit, that is, the first-fit algorithm.

::(b) Put the elements of ''S'' in the knapsack from smallest to largest, that is, the best-fit algorithm.

::(c) Put the elements of ''S'' in the knapsack from largest to smallest.


:1.6

:[[1.7]]

:1.8

:[[1.9]]

:1.10

:[[1.11]]

:1.12

:[[1.13]]

:1.14

:[[1.15]]

:1.16

:[[1.17]]

:1.18

:[[1.19]]

:1.20

:[[1.21]]

:1.22

:[[1.23]]

:1.24

:[[1.25]]

:1.26

:[[1.27]]

:1.28

:[[1.29]]

:1.30

:[[1.31]]

:1.32

:[[1.33]]

:1.34

:[[1.35]]

:1.36

:[[1.37]]

:1.38


Back to [[Problem Solutions]]</text>
      <sha1>oobh3wqc24wcxb0shb75cfb5rq5wmnl</sha1>
    </revision>
    <revision>
      <id>8</id>
      <parentid>7</parentid>
      <timestamp>2020-08-23T19:27:53Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="2277">Problems

:[[1.1]]. Show that ''a'' + ''b'' can be less than ''min(a, b)''.


:1.2. Show that ''a'' × ''b'' can be less than ''min(a, b)''.


:[[1.3]]. Design/draw a road network with two points ''a'' and ''b'' such that the fastest route between ''a'' and ''b'' is not the shortest route.


:1.4. Design/draw a road network with two points ''a'' and ''b'' such that the shortest route between ''a'' and ''b'' is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers ''S'' = {''s1, s2. . . , sn''}, and a target number ''T'', find a subset of ''S'' that adds up exactly to ''T''. For example, there exists a subset within ''S'' = {1, 2, 5, 9, 10} that adds up to ''T'' = 22 but not ''T'' = 23.

:Find counterexamples to each of the following algorithms for the knapsack problem. That is, give an ''S'' and ''T'' where the algorithm does not find a solution that leaves the knapsack completely full, even though a full-knapsack solution exists.

::(a) Put the elements of ''S'' in the knapsack in left to right order if they fit, that is, the first-fit algorithm.

::(b) Put the elements of ''S'' in the knapsack from smallest to largest, that is, the best-fit algorithm.

::(c) Put the elements of ''S'' in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set ''S'' of subsets ''S1, . . . , Sm'' of the universal set ''U'' = {1, ..., ''n''}, find the smallest subset of subsets ''T ⊆ S'' such that ''∪ti∈T ti'' = ''U''. For example, consider the subsets ''S1'' = {1, 3, 5}, ''S2'' = {2, 4}, ''S3'' = {1, 4}, and ''S4'' = {2, 5}. The set cover of {1, . . . , 5} would then be ''S1'' and ''S2''.
:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.

:[[1.7]]

:1.8

:[[1.9]]

:1.10

:[[1.11]]

:1.12

:[[1.13]]

:1.14

:[[1.15]]

:1.16

:[[1.17]]

:1.18

:[[1.19]]

:1.20

:[[1.21]]

:1.22

:[[1.23]]

:1.24

:[[1.25]]

:1.26

:[[1.27]]

:1.28

:[[1.29]]

:1.30

:[[1.31]]

:1.32

:[[1.33]]

:1.34

:[[1.35]]

:1.36

:[[1.37]]

:1.38


Back to [[Problem Solutions]]</text>
      <sha1>it2srqo78va55ql1wg2hztsuqk96v5s</sha1>
    </revision>
    <revision>
      <id>12</id>
      <parentid>8</parentid>
      <timestamp>2020-08-23T19:31:01Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="2272">Problems

:[[1.1]]. Show that ''a'' + ''b'' can be less than ''min(a, b)''.


:1.2. Show that ''a'' × ''b'' can be less than ''min(a, b)''.


:[[1.3]]. Design/draw a road network with two points ''a'' and ''b'' such that the fastest route between ''a'' and ''b'' is not the shortest route.


:1.4. Design/draw a road network with two points ''a'' and ''b'' such that the shortest route between ''a'' and ''b'' is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers ''S'' = {''s1, s2. . . , sn''}, and a target number ''T'', find a subset of ''S'' that adds up exactly to ''T''. For example, there exists a subset within ''S'' = {1, 2, 5, 9, 10} that adds up to ''T'' = 22 but not ''T'' = 23.

:Find counterexamples to each of the following algorithms for the knapsack problem. That is, give an ''S'' and ''T'' where the algorithm does not find a solution that leaves the knapsack completely full, even though a full-knapsack solution exists.

::(a) Put the elements of ''S'' in the knapsack in left to right order if they fit, that is, the first-fit algorithm.

::(b) Put the elements of ''S'' in the knapsack from smallest to largest, that is, the best-fit algorithm.

::(c) Put the elements of ''S'' in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set ''S'' of subsets ''S1, . . . , Sm'' of the universal set ''U'' = {1, ..., ''n''}, find the smallest subset of subsets ''T ⊆ S'' such that ''∪ti∈T ti'' = ''U''. For example, consider the subsets ''S1'' = {1, 3, 5}, ''S2'' = {2, 4}, ''S3'' = {1, 4}, and ''S4'' = {2, 5}. The set cover of {1, . . . , 5} would then be ''S1'' and ''S2''.
:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.

:[[1.7]]

:1.8

:[[1.9]]

:1.10

:[[1.11]]

:1.12

:[[1.13]]

:1.14

:[[1.15]]

:1.16

:[[1.17]]

:1.18

:[[1.19]]

:1.20

:[[1.21]]

:1.22

:[[1.23]]

:1.24

:[[1.25]]

:1.26

:[[1.27]]

:1.28

:[[1.29]]

:1.30

:[[1.31]]

:1.32

:[[1.33]]

:1.34

:[[1.35]]

:1.36

:[[1.37]]

:1.38


Back to [[Chapter List]]</text>
      <sha1>95f2behjw8hoppsj7mejyeh5jg2570u</sha1>
    </revision>
    <revision>
      <id>25</id>
      <parentid>12</parentid>
      <timestamp>2020-08-23T19:47:52Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="2768">Problems

:[[1.1]]. Show that ''a'' + ''b'' can be less than ''min(a, b)''.


:1.2. Show that ''a'' × ''b'' can be less than ''min(a, b)''.


:[[1.3]]. Design/draw a road network with two points ''a'' and ''b'' such that the fastest route between ''a'' and ''b'' is not the shortest route.


:1.4. Design/draw a road network with two points ''a'' and ''b'' such that the shortest route between ''a'' and ''b'' is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers ''S'' = {''s1, s2. . . , sn''}, and a target number ''T'', find a subset of ''S'' that adds up exactly to ''T''. For example, there exists a subset within ''S'' = {1, 2, 5, 9, 10} that adds up to ''T'' = 22 but not ''T'' = 23.

:Find counterexamples to each of the following algorithms for the knapsack problem. That is, give an ''S'' and ''T'' where the algorithm does not find a solution that leaves the knapsack completely full, even though a full-knapsack solution exists.

::(a) Put the elements of ''S'' in the knapsack in left to right order if they fit, that is, the first-fit algorithm.

::(b) Put the elements of ''S'' in the knapsack from smallest to largest, that is, the best-fit algorithm.

::(c) Put the elements of ''S'' in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set ''S'' of subsets ''S1, . . . , Sm'' of the universal set ''U'' = {1, ..., ''n''}, find the smallest subset of subsets ''T ⊆ S'' such that ''∪ti∈T ti'' = ''U''. For example, consider the subsets ''S1'' = {1, 3, 5}, ''S2'' = {2, 4}, ''S3'' = {1, 4}, and ''S4'' = {2, 5}. The set cover of {1, . . . , 5} would then be ''S1'' and ''S2''.
:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph ''G'' = (''V'', ''E'') asks for the largest subset ''C'' of vertices ''V'' such that there is an edge in ''E'' between every pair of vertices in ''C''. Find a counterexample for the following algorithm: Sort the vertices of ''G'' from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.

:1.8

:[[1.9]]

:1.10

:[[1.11]]

:1.12

:[[1.13]]

:1.14

:[[1.15]]

:1.16

:[[1.17]]

:1.18

:[[1.19]]

:1.20

:[[1.21]]

:1.22

:[[1.23]]

:1.24

:[[1.25]]

:1.26

:[[1.27]]

:1.28

:[[1.29]]

:1.30

:[[1.31]]

:1.32

:[[1.33]]

:1.34

:[[1.35]]

:1.36

:[[1.37]]

:1.38


Back to [[Chapter List]]</text>
      <sha1>s6opna9jdfwimtb5ikctyow0w6k11lx</sha1>
    </revision>
    <revision>
      <id>26</id>
      <parentid>25</parentid>
      <timestamp>2020-08-23T19:54:19Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="3277">Problems


:[[1.1]]. Show that ''a'' + ''b'' can be less than ''min(a, b)''.


:1.2. Show that ''a'' × ''b'' can be less than ''min(a, b)''.


:[[1.3]]. Design/draw a road network with two points ''a'' and ''b'' such that the fastest route between ''a'' and ''b'' is not the shortest route.


:1.4. Design/draw a road network with two points ''a'' and ''b'' such that the shortest route between ''a'' and ''b'' is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers ''S'' = {''s1, s2. . . , sn''}, and a target number ''T'', find a subset of ''S'' that adds up exactly to ''T''. For example, there exists a subset within ''S'' = {1, 2, 5, 9, 10} that adds up to ''T'' = 22 but not ''T'' = 23.

:Find counterexamples to each of the following algorithms for the knapsack problem. That is, give an ''S'' and ''T'' where the algorithm does not find a solution that leaves the knapsack completely full, even though a full-knapsack solution exists.

::(a) Put the elements of ''S'' in the knapsack in left to right order if they fit, that is, the first-fit algorithm.

::(b) Put the elements of ''S'' in the knapsack from smallest to largest, that is, the best-fit algorithm.

::(c) Put the elements of ''S'' in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set ''S'' of subsets ''S1, . . . , Sm'' of the universal set ''U'' = {1, ..., ''n''}, find the smallest subset of subsets ''T ⊆ S'' such that ''∪ti∈T ti'' = ''U''. For example, consider the subsets ''S1'' = {1, 3, 5}, ''S2'' = {2, 4}, ''S3'' = {1, 4}, and ''S4'' = {2, 5}. The set cover of {1, . . . , 5} would then be ''S1'' and ''S2''.
:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph ''G'' = (''V'', ''E'') asks for the largest subset ''C'' of vertices ''V'' such that there is an edge in ''E'' between every pair of vertices in ''C''. Find a counterexample for the following algorithm: Sort the vertices of ''G'' from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.


:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants c ≥ 2.
::Multiply(''y, z'')
:::''if z'' = 0 ''then'' return(0) ''else''
:::return(Multiply(''cy'', [''z/c'']) + ''y'' · (''z'' mod ''c''))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial
''anxn + an−1xn−1 + · · · + a1x + a0''.
::Horner(''a, x'')
:::'p'' = ''an''
:::for ''i'' from ''n'' − 1 to 0
::::''p'' = ''p · x'' + ''ai''
:::return ''p''


:1.10

:[[1.11]]

:1.12

:[[1.13]]

:1.14

:[[1.15]]

:1.16

:[[1.17]]

:1.18

:[[1.19]]

:1.20

:[[1.21]]

:1.22

:[[1.23]]

:1.24

:[[1.25]]

:1.26

:[[1.27]]

:1.28

:[[1.29]]

:1.30

:[[1.31]]

:1.32

:[[1.33]]

:1.34

:[[1.35]]

:1.36

:[[1.37]]

:1.38


Back to [[Chapter List]]</text>
      <sha1>6iiao3y1kr0xzqv87pgfq6jqzsn3d13</sha1>
    </revision>
    <revision>
      <id>27</id>
      <parentid>26</parentid>
      <timestamp>2020-08-23T19:55:58Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="3277">Problems


:[[1.1]]. Show that ''a'' + ''b'' can be less than ''min(a, b)''.


:1.2. Show that ''a'' × ''b'' can be less than ''min(a, b)''.


:[[1.3]]. Design/draw a road network with two points ''a'' and ''b'' such that the fastest route between ''a'' and ''b'' is not the shortest route.


:1.4. Design/draw a road network with two points ''a'' and ''b'' such that the shortest route between ''a'' and ''b'' is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers ''S'' = {''s1, s2. . . , sn''}, and a target number ''T'', find a subset of ''S'' that adds up exactly to ''T''. For example, there exists a subset within ''S'' = {1, 2, 5, 9, 10} that adds up to ''T'' = 22 but not ''T'' = 23.

:Find counterexamples to each of the following algorithms for the knapsack problem. That is, give an ''S'' and ''T'' where the algorithm does not find a solution that leaves the knapsack completely full, even though a full-knapsack solution exists.

::(a) Put the elements of ''S'' in the knapsack in left to right order if they fit, that is, the first-fit algorithm.

::(b) Put the elements of ''S'' in the knapsack from smallest to largest, that is, the best-fit algorithm.

::(c) Put the elements of ''S'' in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set ''S'' of subsets ''S1, . . . , Sm'' of the universal set ''U'' = {1, ..., ''n''}, find the smallest subset of subsets ''T ⊆ S'' such that ''∪ti∈T ti'' = ''U''. For example, consider the subsets ''S1'' = {1, 3, 5}, ''S2'' = {2, 4}, ''S3'' = {1, 4}, and ''S4'' = {2, 5}. The set cover of {1, . . . , 5} would then be ''S1'' and ''S2''.
:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph ''G'' = (''V'', ''E'') asks for the largest subset ''C'' of vertices ''V'' such that there is an edge in ''E'' between every pair of vertices in ''C''. Find a counterexample for the following algorithm: Sort the vertices of ''G'' from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.


:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants c ≥ 2.
::Multiply(''y, z'')
:::''if z'' = 0 ''then'' return(0) ''else''
:::return(Multiply(''cy'', [''z/c'']) + ''y'' · (''z'' mod ''c''))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial ''anxn + an−1xn−1 + · · · + a1x + a0''.
::Horner(''a, x'')
:::'p'' = ''an''
:::for ''i'' from ''n'' − 1 to 0
::::''p'' = ''p · x'' + ''ai''
:::return ''p''


:1.10

:[[1.11]]

:1.12

:[[1.13]]

:1.14

:[[1.15]]

:1.16

:[[1.17]]

:1.18

:[[1.19]]

:1.20

:[[1.21]]

:1.22

:[[1.23]]

:1.24

:[[1.25]]

:1.26

:[[1.27]]

:1.28

:[[1.29]]

:1.30

:[[1.31]]

:1.32

:[[1.33]]

:1.34

:[[1.35]]

:1.36

:[[1.37]]

:1.38


Back to [[Chapter List]]</text>
      <sha1>9kcolwru0s8vqrwlciocjhj3kfb78t3</sha1>
    </revision>
    <revision>
      <id>28</id>
      <parentid>27</parentid>
      <timestamp>2020-08-23T20:00:49Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="3278">Problems


:[[1.1]]. Show that ''a'' + ''b'' can be less than ''min(a, b)''.


:1.2. Show that ''a'' × ''b'' can be less than ''min(a, b)''.


:[[1.3]]. Design/draw a road network with two points ''a'' and ''b'' such that the fastest route between ''a'' and ''b'' is not the shortest route.


:1.4. Design/draw a road network with two points ''a'' and ''b'' such that the shortest route between ''a'' and ''b'' is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers ''S'' = {''s1, s2. . . , sn''}, and a target number ''T'', find a subset of ''S'' that adds up exactly to ''T''. For example, there exists a subset within ''S'' = {1, 2, 5, 9, 10} that adds up to ''T'' = 22 but not ''T'' = 23.

:Find counterexamples to each of the following algorithms for the knapsack problem. That is, give an ''S'' and ''T'' where the algorithm does not find a solution that leaves the knapsack completely full, even though a full-knapsack solution exists.

::(a) Put the elements of ''S'' in the knapsack in left to right order if they fit, that is, the first-fit algorithm.

::(b) Put the elements of ''S'' in the knapsack from smallest to largest, that is, the best-fit algorithm.

::(c) Put the elements of ''S'' in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set ''S'' of subsets ''S1, . . . , Sm'' of the universal set ''U'' = {1, ..., ''n''}, find the smallest subset of subsets ''T ⊆ S'' such that ''∪ti∈T ti'' = ''U''. For example, consider the subsets ''S1'' = {1, 3, 5}, ''S2'' = {2, 4}, ''S3'' = {1, 4}, and ''S4'' = {2, 5}. The set cover of {1, . . . , 5} would then be ''S1'' and ''S2''.
:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph ''G'' = (''V'', ''E'') asks for the largest subset ''C'' of vertices ''V'' such that there is an edge in ''E'' between every pair of vertices in ''C''. Find a counterexample for the following algorithm: Sort the vertices of ''G'' from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.


:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants c ≥ 2.
::Multiply(''y, z'')
:::''if z'' = 0 ''then'' return(0) ''else''
:::return(Multiply(''cy'', [''z/c'']) + ''y'' · (''z'' mod ''c''))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial ''anxn + an−1xn−1 + · · · + a1x + a0''.
::Horner(''a, x'')
:::''p'' = ''an''
:::for ''i'' from ''n'' − 1 to 0
::::''p'' = ''p · x'' + ''ai''
:::return ''p''


:1.10

:[[1.11]]

:1.12

:[[1.13]]

:1.14

:[[1.15]]

:1.16

:[[1.17]]

:1.18

:[[1.19]]

:1.20

:[[1.21]]

:1.22

:[[1.23]]

:1.24

:[[1.25]]

:1.26

:[[1.27]]

:1.28

:[[1.29]]

:1.30

:[[1.31]]

:1.32

:[[1.33]]

:1.34

:[[1.35]]

:1.36

:[[1.37]]

:1.38


Back to [[Chapter List]]</text>
      <sha1>b05nbytx1vdvi3olm9gqwmx3krw3bqz</sha1>
    </revision>
    <revision>
      <id>29</id>
      <parentid>28</parentid>
      <timestamp>2020-08-23T20:01:27Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="3282">Problems


:[[1.1]]. Show that ''a'' + ''b'' can be less than ''min(a, b)''.


:1.2. Show that ''a'' × ''b'' can be less than ''min(a, b)''.


:[[1.3]]. Design/draw a road network with two points ''a'' and ''b'' such that the fastest route between ''a'' and ''b'' is not the shortest route.


:1.4. Design/draw a road network with two points ''a'' and ''b'' such that the shortest route between ''a'' and ''b'' is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers ''S'' = {''s1, s2. . . , sn''}, and a target number ''T'', find a subset of ''S'' that adds up exactly to ''T''. For example, there exists a subset within ''S'' = {1, 2, 5, 9, 10} that adds up to ''T'' = 22 but not ''T'' = 23.

:Find counterexamples to each of the following algorithms for the knapsack problem. That is, give an ''S'' and ''T'' where the algorithm does not find a solution that leaves the knapsack completely full, even though a full-knapsack solution exists.

::(a) Put the elements of ''S'' in the knapsack in left to right order if they fit, that is, the first-fit algorithm.

::(b) Put the elements of ''S'' in the knapsack from smallest to largest, that is, the best-fit algorithm.

::(c) Put the elements of ''S'' in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set ''S'' of subsets ''S1, . . . , Sm'' of the universal set ''U'' = {1, ..., ''n''}, find the smallest subset of subsets ''T ⊆ S'' such that ''∪ti∈T ti'' = ''U''. For example, consider the subsets ''S1'' = {1, 3, 5}, ''S2'' = {2, 4}, ''S3'' = {1, 4}, and ''S4'' = {2, 5}. The set cover of {1, . . . , 5} would then be ''S1'' and ''S2''.
:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph ''G'' = (''V'', ''E'') asks for the largest subset ''C'' of vertices ''V'' such that there is an edge in ''E'' between every pair of vertices in ''C''. Find a counterexample for the following algorithm: Sort the vertices of ''G'' from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.


:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants ''c'' ≥ 2.
::Multiply(''y, z'')
:::''if z'' = 0 ''then'' return(0) ''else''
:::return(Multiply(''cy'', [''z/c'']) + ''y'' · (''z'' mod ''c''))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial ''anxn + an−1xn−1 + · · · + a1x + a0''.
::Horner(''a, x'')
:::''p'' = ''an''
:::for ''i'' from ''n'' − 1 to 0
::::''p'' = ''p · x'' + ''ai''
:::return ''p''


:1.10

:[[1.11]]

:1.12

:[[1.13]]

:1.14

:[[1.15]]

:1.16

:[[1.17]]

:1.18

:[[1.19]]

:1.20

:[[1.21]]

:1.22

:[[1.23]]

:1.24

:[[1.25]]

:1.26

:[[1.27]]

:1.28

:[[1.29]]

:1.30

:[[1.31]]

:1.32

:[[1.33]]

:1.34

:[[1.35]]

:1.36

:[[1.37]]

:1.38


Back to [[Chapter List]]</text>
      <sha1>s7cdho8xwwv2t45si5m7eod2c3qzhkf</sha1>
    </revision>
    <revision>
      <id>30</id>
      <parentid>29</parentid>
      <timestamp>2020-08-23T20:03:09Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="3281">Problems

:[[1.1]]. Show that ''a'' + ''b'' can be less than ''min(a, b)''.


:1.2. Show that ''a'' × ''b'' can be less than ''min(a, b)''.


:[[1.3]]. Design/draw a road network with two points ''a'' and ''b'' such that the fastest route between ''a'' and ''b'' is not the shortest route.


:1.4. Design/draw a road network with two points ''a'' and ''b'' such that the shortest route between ''a'' and ''b'' is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers ''S'' = {''s1, s2. . . , sn''}, and a target number ''T'', find a subset of ''S'' that adds up exactly to ''T''. For example, there exists a subset within ''S'' = {1, 2, 5, 9, 10} that adds up to ''T'' = 22 but not ''T'' = 23.

:Find counterexamples to each of the following algorithms for the knapsack problem. That is, give an ''S'' and ''T'' where the algorithm does not find a solution that leaves the knapsack completely full, even though a full-knapsack solution exists.

::(a) Put the elements of ''S'' in the knapsack in left to right order if they fit, that is, the first-fit algorithm.

::(b) Put the elements of ''S'' in the knapsack from smallest to largest, that is, the best-fit algorithm.

::(c) Put the elements of ''S'' in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set ''S'' of subsets ''S1, . . . , Sm'' of the universal set ''U'' = {1, ..., ''n''}, find the smallest subset of subsets ''T ⊆ S'' such that ''∪ti∈T ti'' = ''U''. For example, consider the subsets ''S1'' = {1, 3, 5}, ''S2'' = {2, 4}, ''S3'' = {1, 4}, and ''S4'' = {2, 5}. The set cover of {1, . . . , 5} would then be ''S1'' and ''S2''.
:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph ''G'' = (''V'', ''E'') asks for the largest subset ''C'' of vertices ''V'' such that there is an edge in ''E'' between every pair of vertices in ''C''. Find a counterexample for the following algorithm: Sort the vertices of ''G'' from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.


:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants ''c'' ≥ 2.
::Multiply(''y, z'')
:::''if z'' = 0 ''then'' return(0) ''else''
:::return(Multiply(''cy'', [''z/c'']) + ''y'' · (''z'' mod ''c''))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial ''anxn + an−1xn−1 + · · · + a1x + a0''.
::Horner(''a, x'')
:::''p'' = ''an''
:::for ''i'' from ''n'' − 1 to 0
::::''p'' = ''p · x'' + ''ai''
:::return ''p''


:1.10

:[[1.11]]

:1.12

:[[1.13]]

:1.14

:[[1.15]]

:1.16

:[[1.17]]

:1.18

:[[1.19]]

:1.20

:[[1.21]]

:1.22

:[[1.23]]

:1.24

:[[1.25]]

:1.26

:[[1.27]]

:1.28

:[[1.29]]

:1.30

:[[1.31]]

:1.32

:[[1.33]]

:1.34

:[[1.35]]

:1.36

:[[1.37]]

:1.38


Back to [[Chapter List]]</text>
      <sha1>lk8di60usyffcth5u02qouoro1zf9p3</sha1>
    </revision>
    <revision>
      <id>31</id>
      <parentid>30</parentid>
      <timestamp>2020-08-23T20:07:33Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="3562">Problems

:[[1.1]]. Show that &lt;math&gt;a + b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:1.2. Show that &lt;math&gt;a \times b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:[[1.3]]. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the fastest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the shortest route.


:1.4. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the
shortest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the route with the fewest turns.


:[[1.5]].The ''knapsack problem'' 
is as follows: given a set of integers &lt;math&gt;S = \{s_1, s_2, \ldots, s_n\}&lt;/math&gt;, and
a target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; which adds up
exactly to &lt;math&gt;T&lt;/math&gt;.
For example, there exists a subset within &lt;math&gt;S = \{1, 2, 5, 9, 10\}&lt;/math&gt; that
adds up to &lt;math&gt;T=22&lt;/math&gt; but not &lt;math&gt;T=23&lt;/math&gt;.
Find counterexamples to each of the following algorithms for the knapsack
problem.
That is, giving an &lt;math&gt;S&lt;/math&gt; and &lt;math&gt;T&lt;/math&gt; such that the subset is
selected using the algorithm does not leave the knapsack completely full,
even though such a solution exists.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack in left to right order if they fit, i.e. the first-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from smallest to largest, i.e. the best-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from largest to smallest.


:1.6. The ''set cover problem''
is as follows: given a set of subsets &lt;math&gt; S_1, ..., S_m&lt;/math&gt;
of the universal set &lt;math&gt;U = \{1,...,n\}&lt;/math&gt;,
find the smallest subset of subsets &lt;math&gt;T \subset S&lt;/math&gt;
such that &lt;math&gt;\cup_{t_i \in T} t_i = U&lt;/math&gt;.
For example, there are the following subsets, &lt;math&gt;S_1 = \{1, 3, 5\}&lt;/math&gt;,
&lt;math&gt;S_2 = \{2,4\}&lt;/math&gt;, &lt;math&gt;S_3 = \{1,4\}&lt;/math&gt;, and &lt;math&gt;S_4 = \{2,5\}&lt;/math&gt;
The set cover would then be &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt;.
Find a counterexample for the following algorithm:
Select the largest subset for the cover,
and then delete all its elements from the universal set.
Repeat by adding the subset containing the largest number of
uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph ''G'' = (''V'', ''E'') asks for the largest subset ''C'' of vertices ''V'' such that there is an edge in ''E'' between every pair of vertices in ''C''. Find a counterexample for the following algorithm: Sort the vertices of ''G'' from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.


:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants ''c'' ≥ 2.
::Multiply(''y, z'')
:::''if z'' = 0 ''then'' return(0) ''else''
:::return(Multiply(''cy'', [''z/c'']) + ''y'' · (''z'' mod ''c''))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial ''anxn + an−1xn−1 + · · · + a1x + a0''.
::Horner(''a, x'')
:::''p'' = ''an''
:::for ''i'' from ''n'' − 1 to 0
::::''p'' = ''p · x'' + ''ai''
:::return ''p''


:1.10

:[[1.11]]

:1.12

:[[1.13]]

:1.14

:[[1.15]]

:1.16

:[[1.17]]

:1.18

:[[1.19]]

:1.20

:[[1.21]]

:1.22

:[[1.23]]

:1.24

:[[1.25]]

:1.26

:[[1.27]]

:1.28

:[[1.29]]

:1.30

:[[1.31]]

:1.32

:[[1.33]]

:1.34

:[[1.35]]

:1.36

:[[1.37]]

:1.38


Back to [[Chapter List]]</text>
      <sha1>nd9tqu857bfl0mr9kbwivaitvhmr4cj</sha1>
    </revision>
    <revision>
      <id>32</id>
      <parentid>31</parentid>
      <timestamp>2020-08-23T20:08:49Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Undo revision 31 by [[Special:Contributions/Algowikiadmin|Algowikiadmin]] ([[User talk:Algowikiadmin|talk]])</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="3281">Problems

:[[1.1]]. Show that ''a'' + ''b'' can be less than ''min(a, b)''.


:1.2. Show that ''a'' × ''b'' can be less than ''min(a, b)''.


:[[1.3]]. Design/draw a road network with two points ''a'' and ''b'' such that the fastest route between ''a'' and ''b'' is not the shortest route.


:1.4. Design/draw a road network with two points ''a'' and ''b'' such that the shortest route between ''a'' and ''b'' is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers ''S'' = {''s1, s2. . . , sn''}, and a target number ''T'', find a subset of ''S'' that adds up exactly to ''T''. For example, there exists a subset within ''S'' = {1, 2, 5, 9, 10} that adds up to ''T'' = 22 but not ''T'' = 23.

:Find counterexamples to each of the following algorithms for the knapsack problem. That is, give an ''S'' and ''T'' where the algorithm does not find a solution that leaves the knapsack completely full, even though a full-knapsack solution exists.

::(a) Put the elements of ''S'' in the knapsack in left to right order if they fit, that is, the first-fit algorithm.

::(b) Put the elements of ''S'' in the knapsack from smallest to largest, that is, the best-fit algorithm.

::(c) Put the elements of ''S'' in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set ''S'' of subsets ''S1, . . . , Sm'' of the universal set ''U'' = {1, ..., ''n''}, find the smallest subset of subsets ''T ⊆ S'' such that ''∪ti∈T ti'' = ''U''. For example, consider the subsets ''S1'' = {1, 3, 5}, ''S2'' = {2, 4}, ''S3'' = {1, 4}, and ''S4'' = {2, 5}. The set cover of {1, . . . , 5} would then be ''S1'' and ''S2''.
:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph ''G'' = (''V'', ''E'') asks for the largest subset ''C'' of vertices ''V'' such that there is an edge in ''E'' between every pair of vertices in ''C''. Find a counterexample for the following algorithm: Sort the vertices of ''G'' from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.


:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants ''c'' ≥ 2.
::Multiply(''y, z'')
:::''if z'' = 0 ''then'' return(0) ''else''
:::return(Multiply(''cy'', [''z/c'']) + ''y'' · (''z'' mod ''c''))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial ''anxn + an−1xn−1 + · · · + a1x + a0''.
::Horner(''a, x'')
:::''p'' = ''an''
:::for ''i'' from ''n'' − 1 to 0
::::''p'' = ''p · x'' + ''ai''
:::return ''p''


:1.10

:[[1.11]]

:1.12

:[[1.13]]

:1.14

:[[1.15]]

:1.16

:[[1.17]]

:1.18

:[[1.19]]

:1.20

:[[1.21]]

:1.22

:[[1.23]]

:1.24

:[[1.25]]

:1.26

:[[1.27]]

:1.28

:[[1.29]]

:1.30

:[[1.31]]

:1.32

:[[1.33]]

:1.34

:[[1.35]]

:1.36

:[[1.37]]

:1.38


Back to [[Chapter List]]</text>
      <sha1>lk8di60usyffcth5u02qouoro1zf9p3</sha1>
    </revision>
    <revision>
      <id>33</id>
      <parentid>32</parentid>
      <timestamp>2020-08-23T20:11:00Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="3311">=Introduction to Algorithms=

Problems

:[[1.1]]. Show that ''a'' + ''b'' can be less than ''min(a, b)''.


:1.2. Show that ''a'' × ''b'' can be less than ''min(a, b)''.


:[[1.3]]. Design/draw a road network with two points ''a'' and ''b'' such that the fastest route between ''a'' and ''b'' is not the shortest route.


:1.4. Design/draw a road network with two points ''a'' and ''b'' such that the shortest route between ''a'' and ''b'' is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers ''S'' = {''s1, s2. . . , sn''}, and a target number ''T'', find a subset of ''S'' that adds up exactly to ''T''. For example, there exists a subset within ''S'' = {1, 2, 5, 9, 10} that adds up to ''T'' = 22 but not ''T'' = 23.

:Find counterexamples to each of the following algorithms for the knapsack problem. That is, give an ''S'' and ''T'' where the algorithm does not find a solution that leaves the knapsack completely full, even though a full-knapsack solution exists.

::(a) Put the elements of ''S'' in the knapsack in left to right order if they fit, that is, the first-fit algorithm.

::(b) Put the elements of ''S'' in the knapsack from smallest to largest, that is, the best-fit algorithm.

::(c) Put the elements of ''S'' in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set ''S'' of subsets ''S1, . . . , Sm'' of the universal set ''U'' = {1, ..., ''n''}, find the smallest subset of subsets ''T ⊆ S'' such that ''∪ti∈T ti'' = ''U''. For example, consider the subsets ''S1'' = {1, 3, 5}, ''S2'' = {2, 4}, ''S3'' = {1, 4}, and ''S4'' = {2, 5}. The set cover of {1, . . . , 5} would then be ''S1'' and ''S2''.
:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph ''G'' = (''V'', ''E'') asks for the largest subset ''C'' of vertices ''V'' such that there is an edge in ''E'' between every pair of vertices in ''C''. Find a counterexample for the following algorithm: Sort the vertices of ''G'' from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.


:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants ''c'' ≥ 2.
::Multiply(''y, z'')
:::''if z'' = 0 ''then'' return(0) ''else''
:::return(Multiply(''cy'', [''z/c'']) + ''y'' · (''z'' mod ''c''))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial ''anxn + an−1xn−1 + · · · + a1x + a0''.
::Horner(''a, x'')
:::''p'' = ''an''
:::for ''i'' from ''n'' − 1 to 0
::::''p'' = ''p · x'' + ''ai''
:::return ''p''


:1.10

:[[1.11]]

:1.12

:[[1.13]]

:1.14

:[[1.15]]

:1.16

:[[1.17]]

:1.18

:[[1.19]]

:1.20

:[[1.21]]

:1.22

:[[1.23]]

:1.24

:[[1.25]]

:1.26

:[[1.27]]

:1.28

:[[1.29]]

:1.30

:[[1.31]]

:1.32

:[[1.33]]

:1.34

:[[1.35]]

:1.36

:[[1.37]]

:1.38


Back to [[Chapter List]]</text>
      <sha1>jj41uojzl0ol5oxfwv8vq3zzxqm2crk</sha1>
    </revision>
    <revision>
      <id>34</id>
      <parentid>33</parentid>
      <timestamp>2020-08-23T20:13:00Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="3333">=Introduction to Algorithms=

===Finding Counter Examples===

:[[1.1]]. Show that ''a'' + ''b'' can be less than ''min(a, b)''.


:1.2. Show that ''a'' × ''b'' can be less than ''min(a, b)''.


:[[1.3]]. Design/draw a road network with two points ''a'' and ''b'' such that the fastest route between ''a'' and ''b'' is not the shortest route.


:1.4. Design/draw a road network with two points ''a'' and ''b'' such that the shortest route between ''a'' and ''b'' is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers ''S'' = {''s1, s2. . . , sn''}, and a target number ''T'', find a subset of ''S'' that adds up exactly to ''T''. For example, there exists a subset within ''S'' = {1, 2, 5, 9, 10} that adds up to ''T'' = 22 but not ''T'' = 23.

:Find counterexamples to each of the following algorithms for the knapsack problem. That is, give an ''S'' and ''T'' where the algorithm does not find a solution that leaves the knapsack completely full, even though a full-knapsack solution exists.

::(a) Put the elements of ''S'' in the knapsack in left to right order if they fit, that is, the first-fit algorithm.

::(b) Put the elements of ''S'' in the knapsack from smallest to largest, that is, the best-fit algorithm.

::(c) Put the elements of ''S'' in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set ''S'' of subsets ''S1, . . . , Sm'' of the universal set ''U'' = {1, ..., ''n''}, find the smallest subset of subsets ''T ⊆ S'' such that ''∪ti∈T ti'' = ''U''. For example, consider the subsets ''S1'' = {1, 3, 5}, ''S2'' = {2, 4}, ''S3'' = {1, 4}, and ''S4'' = {2, 5}. The set cover of {1, . . . , 5} would then be ''S1'' and ''S2''.
:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph ''G'' = (''V'', ''E'') asks for the largest subset ''C'' of vertices ''V'' such that there is an edge in ''E'' between every pair of vertices in ''C''. Find a counterexample for the following algorithm: Sort the vertices of ''G'' from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.


:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants ''c'' ≥ 2.
::Multiply(''y, z'')
:::''if z'' = 0 ''then'' return(0) ''else''
:::return(Multiply(''cy'', [''z/c'']) + ''y'' · (''z'' mod ''c''))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial ''anxn + an−1xn−1 + · · · + a1x + a0''.
::Horner(''a, x'')
:::''p'' = ''an''
:::for ''i'' from ''n'' − 1 to 0
::::''p'' = ''p · x'' + ''ai''
:::return ''p''


:1.10

:[[1.11]]

:1.12

:[[1.13]]

:1.14

:[[1.15]]

:1.16

:[[1.17]]

:1.18

:[[1.19]]

:1.20

:[[1.21]]

:1.22

:[[1.23]]

:1.24

:[[1.25]]

:1.26

:[[1.27]]

:1.28

:[[1.29]]

:1.30

:[[1.31]]

:1.32

:[[1.33]]

:1.34

:[[1.35]]

:1.36

:[[1.37]]

:1.38


Back to [[Chapter List]]</text>
      <sha1>c1xrev0jub9oaholnybvor9goemvkdu</sha1>
    </revision>
    <revision>
      <id>35</id>
      <parentid>34</parentid>
      <timestamp>2020-08-23T20:27:05Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="5343">=Introduction to Algorithms=

===Finding Counter Examples===

:[[1.1]]. Show that ''a'' + ''b'' can be less than ''min(a, b)''.


:1.2. Show that ''a'' × ''b'' can be less than ''min(a, b)''.


:[[1.3]]. Design/draw a road network with two points ''a'' and ''b'' such that the fastest route between ''a'' and ''b'' is not the shortest route.


:1.4. Design/draw a road network with two points ''a'' and ''b'' such that the shortest route between ''a'' and ''b'' is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers ''S'' = {''s1, s2. . . , sn''}, and a target number ''T'', find a subset of ''S'' that adds up exactly to ''T''. For example, there exists a subset within ''S'' = {1, 2, 5, 9, 10} that adds up to ''T'' = 22 but not ''T'' = 23.

:Find counterexamples to each of the following algorithms for the knapsack problem. That is, give an ''S'' and ''T'' where the algorithm does not find a solution that leaves the knapsack completely full, even though a full-knapsack solution exists.

::(a) Put the elements of ''S'' in the knapsack in left to right order if they fit, that is, the first-fit algorithm.

::(b) Put the elements of ''S'' in the knapsack from smallest to largest, that is, the best-fit algorithm.

::(c) Put the elements of ''S'' in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set ''S'' of subsets ''S1, . . . , Sm'' of the universal set ''U'' = {1, ..., ''n''}, find the smallest subset of subsets ''T ⊆ S'' such that ''∪ti∈T ti'' = ''U''. For example, consider the subsets ''S1'' = {1, 3, 5}, ''S2'' = {2, 4}, ''S3'' = {1, 4}, and ''S4'' = {2, 5}. The set cover of {1, . . . , 5} would then be ''S1'' and ''S2''.
:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph ''G'' = (''V'', ''E'') asks for the largest subset ''C'' of vertices ''V'' such that there is an edge in ''E'' between every pair of vertices in ''C''. Find a counterexample for the following algorithm: Sort the vertices of ''G'' from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.


===Proofs of Correctness===

:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants ''c'' ≥ 2.
::Multiply(''y, z'')
:::''if z'' = 0 ''then'' return(0) ''else''
:::return(Multiply(''cy'', [''z/c'']) + ''y'' · (''z'' mod ''c''))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial ''anxn + an−1xn−1 + · · · + a1x + a0''.
::Horner(''a, x'')
:::''p'' = ''an''
:::for ''i'' from ''n'' − 1 to 0
::::''p'' = ''p · x'' + ''ai''
:::return ''p''


:1.10. Prove the correctness of the following sorting algorithm.

::Bubblesort (''A'')
:::for ''i'' from ''n'' to 1
::::for ''j'' from 1 to ''i'' − 1
:::::if (''A''[''j''] &gt; ''A''[''j'' + 1])
::::::swap the values of ''A''[''j''] and ''A''[''j'' + 1]


:[[1.11]]. The ''greatest common divisor of positive'' integers ''x'' and ''y'' is the largest integer ''d'' such that ''d'' divides ''x'' and ''d'' divides ''y''. Euclid’s algorithm to compute gcd(''x, y'') where ''x'' &gt; ''y'' reduces the task to a smaller problem:

:::::gcd(''x, y'') = gcd(''y, x'' mod ''y'')

:Prove that Euclid’s algorithm is correct.


===Induction===

:1.12. 


:[[1.13]]


:1.14


:[[1.15]]


:1.16


:[[1.17]]


:1.18


:[[1.19]]


:1.20


===Estimation===

:[[1.21]]. Do all the books you own total at least one million pages? How many total pages are stored in your school library?


:1.22. How many words are there in this textbook?


:[[1.23]]. How many hours are one million seconds? How many days? Answer these questions by doing all arithmetic in your head.


:1.24. Estimate how many cities and towns there are in the United States.


:[[1.25]]. Estimate how many cubic miles of water flow out of the mouth of the Mississippi River each day. Do not look up any supplemental facts. Describe all assumptions you made in arriving at your answer.


:1.26. How many Starbucks or McDonald’s locations are there in your country?


:[[1.27]]. How long would it take to empty a bathtub with a drinking straw?


:1.28. Is disk drive access time normally measured in milliseconds (thousandths of a second) or microseconds (millionths of a second)? Does your RAM memory access a word in more or less than a microsecond? How many instructions can your CPU execute in one year if the machine is left running all the time?


:[[1.29]]. A sorting algorithm takes 1 second to sort 1,000 items on your machine. How long will it take to sort 10,000 items. . .
::(a) if you believe that the algorithm takes time proportional to n2, and
::(b) if you believe that the algorithm takes time roughly proportional to n log n?


===Implementation Projects===

:1.30


:[[1.31]]


:1.32

===Interview Problems===

:[[1.33]]


:1.34


:[[1.35]]


:1.36


:[[1.37]]


:1.38


Back to [[Chapter List]]</text>
      <sha1>0gcm9ahw0avfdvr4aiof84q7eiq5792</sha1>
    </revision>
    <revision>
      <id>36</id>
      <parentid>35</parentid>
      <timestamp>2020-08-23T20:30:22Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="6358">=Introduction to Algorithms=

===Finding Counter Examples===

:[[1.1]]. Show that ''a'' + ''b'' can be less than ''min(a, b)''.


:1.2. Show that ''a'' × ''b'' can be less than ''min(a, b)''.


:[[1.3]]. Design/draw a road network with two points ''a'' and ''b'' such that the fastest route between ''a'' and ''b'' is not the shortest route.


:1.4. Design/draw a road network with two points ''a'' and ''b'' such that the shortest route between ''a'' and ''b'' is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers ''S'' = {''s1, s2. . . , sn''}, and a target number ''T'', find a subset of ''S'' that adds up exactly to ''T''. For example, there exists a subset within ''S'' = {1, 2, 5, 9, 10} that adds up to ''T'' = 22 but not ''T'' = 23.

:Find counterexamples to each of the following algorithms for the knapsack problem. That is, give an ''S'' and ''T'' where the algorithm does not find a solution that leaves the knapsack completely full, even though a full-knapsack solution exists.

::(a) Put the elements of ''S'' in the knapsack in left to right order if they fit, that is, the first-fit algorithm.

::(b) Put the elements of ''S'' in the knapsack from smallest to largest, that is, the best-fit algorithm.

::(c) Put the elements of ''S'' in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set ''S'' of subsets ''S1, . . . , Sm'' of the universal set ''U'' = {1, ..., ''n''}, find the smallest subset of subsets ''T ⊆ S'' such that ''∪ti∈T ti'' = ''U''. For example, consider the subsets ''S1'' = {1, 3, 5}, ''S2'' = {2, 4}, ''S3'' = {1, 4}, and ''S4'' = {2, 5}. The set cover of {1, . . . , 5} would then be ''S1'' and ''S2''.
:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph ''G'' = (''V'', ''E'') asks for the largest subset ''C'' of vertices ''V'' such that there is an edge in ''E'' between every pair of vertices in ''C''. Find a counterexample for the following algorithm: Sort the vertices of ''G'' from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.


===Proofs of Correctness===

:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants ''c'' ≥ 2.
::Multiply(''y, z'')
:::''if z'' = 0 ''then'' return(0) ''else''
:::return(Multiply(''cy'', [''z/c'']) + ''y'' · (''z'' mod ''c''))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial ''anxn + an−1xn−1 + · · · + a1x + a0''.
::Horner(''a, x'')
:::''p'' = ''an''
:::for ''i'' from ''n'' − 1 to 0
::::''p'' = ''p · x'' + ''ai''
:::return ''p''


:1.10. Prove the correctness of the following sorting algorithm.

::Bubblesort (''A'')
:::for ''i'' from ''n'' to 1
::::for ''j'' from 1 to ''i'' − 1
:::::if (''A''[''j''] &gt; ''A''[''j'' + 1])
::::::swap the values of ''A''[''j''] and ''A''[''j'' + 1]


:[[1.11]]. The ''greatest common divisor of positive'' integers ''x'' and ''y'' is the largest integer ''d'' such that ''d'' divides ''x'' and ''d'' divides ''y''. Euclid’s algorithm to compute gcd(''x, y'') where ''x'' &gt; ''y'' reduces the task to a smaller problem:

:::::gcd(''x, y'') = gcd(''y, x'' mod ''y'')

:Prove that Euclid’s algorithm is correct.


===Induction===

:1.12. 


:[[1.13]]


:1.14


:[[1.15]]


:1.16


:[[1.17]]


:1.18


:[[1.19]]


:1.20


===Estimation===

:[[1.21]]. Do all the books you own total at least one million pages? How many total pages are stored in your school library?


:1.22. How many words are there in this textbook?


:[[1.23]]. How many hours are one million seconds? How many days? Answer these questions by doing all arithmetic in your head.


:1.24. Estimate how many cities and towns there are in the United States.


:[[1.25]]. Estimate how many cubic miles of water flow out of the mouth of the Mississippi River each day. Do not look up any supplemental facts. Describe all assumptions you made in arriving at your answer.


:1.26. How many Starbucks or McDonald’s locations are there in your country?


:[[1.27]]. How long would it take to empty a bathtub with a drinking straw?


:1.28. Is disk drive access time normally measured in milliseconds (thousandths of a second) or microseconds (millionths of a second)? Does your RAM memory access a word in more or less than a microsecond? How many instructions can your CPU execute in one year if the machine is left running all the time?


:[[1.29]]. A sorting algorithm takes 1 second to sort 1,000 items on your machine. How long will it take to sort 10,000 items. . .
::(a) if you believe that the algorithm takes time proportional to n2, and
::(b) if you believe that the algorithm takes time roughly proportional to n log n?


===Implementation Projects===

:1.30. Implement the two TSP heuristics of Section 1.1 (page 5). Which of them gives better solutions in practice? Can you devise a heuristic that works better than both of them?


:[[1.31]]. Describe how to test whether a given set of tickets establishes sufficient coverage in the Lotto problem of Section 1.8 (page 22). Write a program to find good ticket sets.


===Interview Problems===

:1.32. Write a function to perform integer division without using either the / or * operators. Find a fast way to do it.


:[[1.33]]. There are twenty-five horses. At most, five horses can race together at a time. You must determine the fastest, second fastest, and third fastest horses. Find the minimum number of races in which this can be done.


:1.34. How many piano tuners are there in the entire world?


:[[1.35]]. How many gas stations are there in the United States?


:1.36. How much does the ice in a hockey rink weigh?


:[[1.37]]. How many miles of road are there in the United States?


:1.38. On average, how many times would you have to flip open the Manhattan phone book at random in order to find a specific name?


Back to [[Chapter List]]</text>
      <sha1>8wnysabmwqx58g944huqhphzahq0lee</sha1>
    </revision>
    <revision>
      <id>39</id>
      <parentid>36</parentid>
      <timestamp>2020-08-24T16:16:00Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="6389">=Introduction to Algorithms=

(find a way to do subscripts)

===Finding Counter Examples===

:[[1.1]]. Show that ''a'' + ''b'' can be less than ''min(a, b)''.


:1.2. Show that ''a'' × ''b'' can be less than ''min(a, b)''.


:[[1.3]]. Design/draw a road network with two points ''a'' and ''b'' such that the fastest route between ''a'' and ''b'' is not the shortest route.


:1.4. Design/draw a road network with two points ''a'' and ''b'' such that the shortest route between ''a'' and ''b'' is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers ''S'' = {''s1, s2. . . , sn''}, and a target number ''T'', find a subset of ''S'' that adds up exactly to ''T''. For example, there exists a subset within ''S'' = {1, 2, 5, 9, 10} that adds up to ''T'' = 22 but not ''T'' = 23.

:Find counterexamples to each of the following algorithms for the knapsack problem. That is, give an ''S'' and ''T'' where the algorithm does not find a solution that leaves the knapsack completely full, even though a full-knapsack solution exists.

::(a) Put the elements of ''S'' in the knapsack in left to right order if they fit, that is, the first-fit algorithm.

::(b) Put the elements of ''S'' in the knapsack from smallest to largest, that is, the best-fit algorithm.

::(c) Put the elements of ''S'' in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set ''S'' of subsets ''S1, . . . , Sm'' of the universal set ''U'' = {1, ..., ''n''}, find the smallest subset of subsets ''T ⊆ S'' such that ''∪ti∈T ti'' = ''U''. For example, consider the subsets ''S1'' = {1, 3, 5}, ''S2'' = {2, 4}, ''S3'' = {1, 4}, and ''S4'' = {2, 5}. The set cover of {1, . . . , 5} would then be ''S1'' and ''S2''.
:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph ''G'' = (''V'', ''E'') asks for the largest subset ''C'' of vertices ''V'' such that there is an edge in ''E'' between every pair of vertices in ''C''. Find a counterexample for the following algorithm: Sort the vertices of ''G'' from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.


===Proofs of Correctness===

:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants ''c'' ≥ 2.
::Multiply(''y, z'')
:::''if z'' = 0 ''then'' return(0) ''else''
:::return(Multiply(''cy'', [''z/c'']) + ''y'' · (''z'' mod ''c''))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial ''anxn + an−1xn−1 + · · · + a1x + a0''.
::Horner(''a, x'')
:::''p'' = ''an''
:::for ''i'' from ''n'' − 1 to 0
::::''p'' = ''p · x'' + ''ai''
:::return ''p''


:1.10. Prove the correctness of the following sorting algorithm.

::Bubblesort (''A'')
:::for ''i'' from ''n'' to 1
::::for ''j'' from 1 to ''i'' − 1
:::::if (''A''[''j''] &gt; ''A''[''j'' + 1])
::::::swap the values of ''A''[''j''] and ''A''[''j'' + 1]


:[[1.11]]. The ''greatest common divisor of positive'' integers ''x'' and ''y'' is the largest integer ''d'' such that ''d'' divides ''x'' and ''d'' divides ''y''. Euclid’s algorithm to compute gcd(''x, y'') where ''x'' &gt; ''y'' reduces the task to a smaller problem:

:::::gcd(''x, y'') = gcd(''y, x'' mod ''y'')

:Prove that Euclid’s algorithm is correct.


===Induction===

:1.12. 


:[[1.13]]


:1.14


:[[1.15]]


:1.16


:[[1.17]]


:1.18


:[[1.19]]


:1.20


===Estimation===

:[[1.21]]. Do all the books you own total at least one million pages? How many total pages are stored in your school library?


:1.22. How many words are there in this textbook?


:[[1.23]]. How many hours are one million seconds? How many days? Answer these questions by doing all arithmetic in your head.


:1.24. Estimate how many cities and towns there are in the United States.


:[[1.25]]. Estimate how many cubic miles of water flow out of the mouth of the Mississippi River each day. Do not look up any supplemental facts. Describe all assumptions you made in arriving at your answer.


:1.26. How many Starbucks or McDonald’s locations are there in your country?


:[[1.27]]. How long would it take to empty a bathtub with a drinking straw?


:1.28. Is disk drive access time normally measured in milliseconds (thousandths of a second) or microseconds (millionths of a second)? Does your RAM memory access a word in more or less than a microsecond? How many instructions can your CPU execute in one year if the machine is left running all the time?


:[[1.29]]. A sorting algorithm takes 1 second to sort 1,000 items on your machine. How long will it take to sort 10,000 items. . .
::(a) if you believe that the algorithm takes time proportional to n2, and
::(b) if you believe that the algorithm takes time roughly proportional to n log n?


===Implementation Projects===

:1.30. Implement the two TSP heuristics of Section 1.1 (page 5). Which of them gives better solutions in practice? Can you devise a heuristic that works better than both of them?


:[[1.31]]. Describe how to test whether a given set of tickets establishes sufficient coverage in the Lotto problem of Section 1.8 (page 22). Write a program to find good ticket sets.


===Interview Problems===

:1.32. Write a function to perform integer division without using either the / or * operators. Find a fast way to do it.


:[[1.33]]. There are twenty-five horses. At most, five horses can race together at a time. You must determine the fastest, second fastest, and third fastest horses. Find the minimum number of races in which this can be done.


:1.34. How many piano tuners are there in the entire world?


:[[1.35]]. How many gas stations are there in the United States?


:1.36. How much does the ice in a hockey rink weigh?


:[[1.37]]. How many miles of road are there in the United States?


:1.38. On average, how many times would you have to flip open the Manhattan phone book at random in order to find a specific name?


Back to [[Chapter List]]</text>
      <sha1>shc4dvsh082kcksefji582kaklushar</sha1>
    </revision>
    <revision>
      <id>40</id>
      <parentid>39</parentid>
      <timestamp>2020-08-31T16:47:03Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Introduction to Algorithms */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="6358">=Introduction to Algorithms=

===Finding Counter Examples===

:[[1.1]]. Show that ''a'' + ''b'' can be less than ''min(a, b)''.


:1.2. Show that ''a'' × ''b'' can be less than ''min(a, b)''.


:[[1.3]]. Design/draw a road network with two points ''a'' and ''b'' such that the fastest route between ''a'' and ''b'' is not the shortest route.


:1.4. Design/draw a road network with two points ''a'' and ''b'' such that the shortest route between ''a'' and ''b'' is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers ''S'' = {''s1, s2. . . , sn''}, and a target number ''T'', find a subset of ''S'' that adds up exactly to ''T''. For example, there exists a subset within ''S'' = {1, 2, 5, 9, 10} that adds up to ''T'' = 22 but not ''T'' = 23.

:Find counterexamples to each of the following algorithms for the knapsack problem. That is, give an ''S'' and ''T'' where the algorithm does not find a solution that leaves the knapsack completely full, even though a full-knapsack solution exists.

::(a) Put the elements of ''S'' in the knapsack in left to right order if they fit, that is, the first-fit algorithm.

::(b) Put the elements of ''S'' in the knapsack from smallest to largest, that is, the best-fit algorithm.

::(c) Put the elements of ''S'' in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set ''S'' of subsets ''S1, . . . , Sm'' of the universal set ''U'' = {1, ..., ''n''}, find the smallest subset of subsets ''T ⊆ S'' such that ''∪ti∈T ti'' = ''U''. For example, consider the subsets ''S1'' = {1, 3, 5}, ''S2'' = {2, 4}, ''S3'' = {1, 4}, and ''S4'' = {2, 5}. The set cover of {1, . . . , 5} would then be ''S1'' and ''S2''.
:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph ''G'' = (''V'', ''E'') asks for the largest subset ''C'' of vertices ''V'' such that there is an edge in ''E'' between every pair of vertices in ''C''. Find a counterexample for the following algorithm: Sort the vertices of ''G'' from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.


===Proofs of Correctness===

:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants ''c'' ≥ 2.
::Multiply(''y, z'')
:::''if z'' = 0 ''then'' return(0) ''else''
:::return(Multiply(''cy'', [''z/c'']) + ''y'' · (''z'' mod ''c''))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial ''anxn + an−1xn−1 + · · · + a1x + a0''.
::Horner(''a, x'')
:::''p'' = ''an''
:::for ''i'' from ''n'' − 1 to 0
::::''p'' = ''p · x'' + ''ai''
:::return ''p''


:1.10. Prove the correctness of the following sorting algorithm.

::Bubblesort (''A'')
:::for ''i'' from ''n'' to 1
::::for ''j'' from 1 to ''i'' − 1
:::::if (''A''[''j''] &gt; ''A''[''j'' + 1])
::::::swap the values of ''A''[''j''] and ''A''[''j'' + 1]


:[[1.11]]. The ''greatest common divisor of positive'' integers ''x'' and ''y'' is the largest integer ''d'' such that ''d'' divides ''x'' and ''d'' divides ''y''. Euclid’s algorithm to compute gcd(''x, y'') where ''x'' &gt; ''y'' reduces the task to a smaller problem:

:::::gcd(''x, y'') = gcd(''y, x'' mod ''y'')

:Prove that Euclid’s algorithm is correct.


===Induction===

:1.12. 


:[[1.13]]


:1.14


:[[1.15]]


:1.16


:[[1.17]]


:1.18


:[[1.19]]


:1.20


===Estimation===

:[[1.21]]. Do all the books you own total at least one million pages? How many total pages are stored in your school library?


:1.22. How many words are there in this textbook?


:[[1.23]]. How many hours are one million seconds? How many days? Answer these questions by doing all arithmetic in your head.


:1.24. Estimate how many cities and towns there are in the United States.


:[[1.25]]. Estimate how many cubic miles of water flow out of the mouth of the Mississippi River each day. Do not look up any supplemental facts. Describe all assumptions you made in arriving at your answer.


:1.26. How many Starbucks or McDonald’s locations are there in your country?


:[[1.27]]. How long would it take to empty a bathtub with a drinking straw?


:1.28. Is disk drive access time normally measured in milliseconds (thousandths of a second) or microseconds (millionths of a second)? Does your RAM memory access a word in more or less than a microsecond? How many instructions can your CPU execute in one year if the machine is left running all the time?


:[[1.29]]. A sorting algorithm takes 1 second to sort 1,000 items on your machine. How long will it take to sort 10,000 items. . .
::(a) if you believe that the algorithm takes time proportional to n2, and
::(b) if you believe that the algorithm takes time roughly proportional to n log n?


===Implementation Projects===

:1.30. Implement the two TSP heuristics of Section 1.1 (page 5). Which of them gives better solutions in practice? Can you devise a heuristic that works better than both of them?


:[[1.31]]. Describe how to test whether a given set of tickets establishes sufficient coverage in the Lotto problem of Section 1.8 (page 22). Write a program to find good ticket sets.


===Interview Problems===

:1.32. Write a function to perform integer division without using either the / or * operators. Find a fast way to do it.


:[[1.33]]. There are twenty-five horses. At most, five horses can race together at a time. You must determine the fastest, second fastest, and third fastest horses. Find the minimum number of races in which this can be done.


:1.34. How many piano tuners are there in the entire world?


:[[1.35]]. How many gas stations are there in the United States?


:1.36. How much does the ice in a hockey rink weigh?


:[[1.37]]. How many miles of road are there in the United States?


:1.38. On average, how many times would you have to flip open the Manhattan phone book at random in order to find a specific name?


Back to [[Chapter List]]</text>
      <sha1>8wnysabmwqx58g944huqhphzahq0lee</sha1>
    </revision>
    <revision>
      <id>41</id>
      <parentid>40</parentid>
      <timestamp>2020-08-31T16:52:44Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Introduction to Algorithms */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="6549">=Introduction to Algorithms=

===Finding Counter Examples===

:[[1.1]]. Show that &lt;math&gt;a + b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:1.2. Show that &lt;math&gt;a \times b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:[[1.3]]. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the fastest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the shortest route.


:1.4. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the shortest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers '&lt;math&gt;S = \{s_1, s_2, \ldots, s_n\}&lt;/math&gt;, and a target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; which adds up exactly to &lt;math&gt;T&lt;/math&gt;.
For example, there exists a subset within &lt;math&gt;S = \{1, 2, 5, 9, 10\}&lt;/math&gt; that
adds up to &lt;math&gt;T=22&lt;/math&gt; but not &lt;math&gt;T=23&lt;/math&gt;.
Find counterexamples to each of the following algorithms for the knapsack
problem.
That is, giving an &lt;math&gt;S&lt;/math&gt; and &lt;math&gt;T&lt;/math&gt; such that the subset is
selected using the algorithm does not leave the knapsack completely full,
even though such a solution exists.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack in left to right order if they fit, i.e. the first-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from smallest to largest, i.e. the best-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set ''S'' of subsets ''S1, . . . , Sm'' of the universal set ''U'' = {1, ..., ''n''}, find the smallest subset of subsets ''T ⊆ S'' such that ''∪ti∈T ti'' = ''U''. For example, consider the subsets ''S1'' = {1, 3, 5}, ''S2'' = {2, 4}, ''S3'' = {1, 4}, and ''S4'' = {2, 5}. The set cover of {1, . . . , 5} would then be ''S1'' and ''S2''.
:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph ''G'' = (''V'', ''E'') asks for the largest subset ''C'' of vertices ''V'' such that there is an edge in ''E'' between every pair of vertices in ''C''. Find a counterexample for the following algorithm: Sort the vertices of ''G'' from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.


===Proofs of Correctness===

:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants ''c'' ≥ 2.
::Multiply(''y, z'')
:::''if z'' = 0 ''then'' return(0) ''else''
:::return(Multiply(''cy'', [''z/c'']) + ''y'' · (''z'' mod ''c''))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial ''anxn + an−1xn−1 + · · · + a1x + a0''.
::Horner(''a, x'')
:::''p'' = ''an''
:::for ''i'' from ''n'' − 1 to 0
::::''p'' = ''p · x'' + ''ai''
:::return ''p''


:1.10. Prove the correctness of the following sorting algorithm.

::Bubblesort (''A'')
:::for ''i'' from ''n'' to 1
::::for ''j'' from 1 to ''i'' − 1
:::::if (''A''[''j''] &gt; ''A''[''j'' + 1])
::::::swap the values of ''A''[''j''] and ''A''[''j'' + 1]


:[[1.11]]. The ''greatest common divisor of positive'' integers ''x'' and ''y'' is the largest integer ''d'' such that ''d'' divides ''x'' and ''d'' divides ''y''. Euclid’s algorithm to compute gcd(''x, y'') where ''x'' &gt; ''y'' reduces the task to a smaller problem:

:::::gcd(''x, y'') = gcd(''y, x'' mod ''y'')

:Prove that Euclid’s algorithm is correct.


===Induction===

:1.12. 


:[[1.13]]


:1.14


:[[1.15]]


:1.16


:[[1.17]]


:1.18


:[[1.19]]


:1.20


===Estimation===

:[[1.21]]. Do all the books you own total at least one million pages? How many total pages are stored in your school library?


:1.22. How many words are there in this textbook?


:[[1.23]]. How many hours are one million seconds? How many days? Answer these questions by doing all arithmetic in your head.


:1.24. Estimate how many cities and towns there are in the United States.


:[[1.25]]. Estimate how many cubic miles of water flow out of the mouth of the Mississippi River each day. Do not look up any supplemental facts. Describe all assumptions you made in arriving at your answer.


:1.26. How many Starbucks or McDonald’s locations are there in your country?


:[[1.27]]. How long would it take to empty a bathtub with a drinking straw?


:1.28. Is disk drive access time normally measured in milliseconds (thousandths of a second) or microseconds (millionths of a second)? Does your RAM memory access a word in more or less than a microsecond? How many instructions can your CPU execute in one year if the machine is left running all the time?


:[[1.29]]. A sorting algorithm takes 1 second to sort 1,000 items on your machine. How long will it take to sort 10,000 items. . .
::(a) if you believe that the algorithm takes time proportional to n2, and
::(b) if you believe that the algorithm takes time roughly proportional to n log n?


===Implementation Projects===

:1.30. Implement the two TSP heuristics of Section 1.1 (page 5). Which of them gives better solutions in practice? Can you devise a heuristic that works better than both of them?


:[[1.31]]. Describe how to test whether a given set of tickets establishes sufficient coverage in the Lotto problem of Section 1.8 (page 22). Write a program to find good ticket sets.


===Interview Problems===

:1.32. Write a function to perform integer division without using either the / or * operators. Find a fast way to do it.


:[[1.33]]. There are twenty-five horses. At most, five horses can race together at a time. You must determine the fastest, second fastest, and third fastest horses. Find the minimum number of races in which this can be done.


:1.34. How many piano tuners are there in the entire world?


:[[1.35]]. How many gas stations are there in the United States?


:1.36. How much does the ice in a hockey rink weigh?


:[[1.37]]. How many miles of road are there in the United States?


:1.38. On average, how many times would you have to flip open the Manhattan phone book at random in order to find a specific name?


Back to [[Chapter List]]</text>
      <sha1>626uqrppki6nb0hel7nqundfp7imegi</sha1>
    </revision>
    <revision>
      <id>42</id>
      <parentid>41</parentid>
      <timestamp>2020-08-31T16:54:35Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Finding Counter Examples */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="6549">=Introduction to Algorithms=

===Finding Counter Examples===

:[[1.1]]. Show that &lt;math&gt;a + b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:1.2. Show that &lt;math&gt;a \times b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:[[1.3]]. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the fastest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the shortest route.


:1.4. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the shortest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers '&lt;math&gt;S = \{s_1, s_2, \ldots, s_n\}&lt;/math&gt;, and a target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; which adds up exactly to &lt;math&gt;T&lt;/math&gt;.
For example, there exists a subset within &lt;math&gt;S = \{1, 2, 5, 9, 10\}&lt;/math&gt; that adds up to &lt;math&gt;T=22&lt;/math&gt; but not &lt;math&gt;T=23&lt;/math&gt;.
:Find counterexamples to each of the following algorithms for the knapsack problem. That is, giving an &lt;math&gt;S&lt;/math&gt; and &lt;math&gt;T&lt;/math&gt; such that the subset is selected using the algorithm does not leave the knapsack completely full, even though such a solution exists.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack in left to right order if they fit, i.e. the first-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from smallest to largest, i.e. the best-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set ''S'' of subsets ''S1, . . . , Sm'' of the universal set ''U'' = {1, ..., ''n''}, find the smallest subset of subsets ''T ⊆ S'' such that ''∪ti∈T ti'' = ''U''. For example, consider the subsets ''S1'' = {1, 3, 5}, ''S2'' = {2, 4}, ''S3'' = {1, 4}, and ''S4'' = {2, 5}. The set cover of {1, . . . , 5} would then be ''S1'' and ''S2''.
:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph ''G'' = (''V'', ''E'') asks for the largest subset ''C'' of vertices ''V'' such that there is an edge in ''E'' between every pair of vertices in ''C''. Find a counterexample for the following algorithm: Sort the vertices of ''G'' from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.

===Proofs of Correctness===

:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants ''c'' ≥ 2.
::Multiply(''y, z'')
:::''if z'' = 0 ''then'' return(0) ''else''
:::return(Multiply(''cy'', [''z/c'']) + ''y'' · (''z'' mod ''c''))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial ''anxn + an−1xn−1 + · · · + a1x + a0''.
::Horner(''a, x'')
:::''p'' = ''an''
:::for ''i'' from ''n'' − 1 to 0
::::''p'' = ''p · x'' + ''ai''
:::return ''p''


:1.10. Prove the correctness of the following sorting algorithm.

::Bubblesort (''A'')
:::for ''i'' from ''n'' to 1
::::for ''j'' from 1 to ''i'' − 1
:::::if (''A''[''j''] &gt; ''A''[''j'' + 1])
::::::swap the values of ''A''[''j''] and ''A''[''j'' + 1]


:[[1.11]]. The ''greatest common divisor of positive'' integers ''x'' and ''y'' is the largest integer ''d'' such that ''d'' divides ''x'' and ''d'' divides ''y''. Euclid’s algorithm to compute gcd(''x, y'') where ''x'' &gt; ''y'' reduces the task to a smaller problem:

:::::gcd(''x, y'') = gcd(''y, x'' mod ''y'')

:Prove that Euclid’s algorithm is correct.


===Induction===

:1.12. 


:[[1.13]]


:1.14


:[[1.15]]


:1.16


:[[1.17]]


:1.18


:[[1.19]]


:1.20


===Estimation===

:[[1.21]]. Do all the books you own total at least one million pages? How many total pages are stored in your school library?


:1.22. How many words are there in this textbook?


:[[1.23]]. How many hours are one million seconds? How many days? Answer these questions by doing all arithmetic in your head.


:1.24. Estimate how many cities and towns there are in the United States.


:[[1.25]]. Estimate how many cubic miles of water flow out of the mouth of the Mississippi River each day. Do not look up any supplemental facts. Describe all assumptions you made in arriving at your answer.


:1.26. How many Starbucks or McDonald’s locations are there in your country?


:[[1.27]]. How long would it take to empty a bathtub with a drinking straw?


:1.28. Is disk drive access time normally measured in milliseconds (thousandths of a second) or microseconds (millionths of a second)? Does your RAM memory access a word in more or less than a microsecond? How many instructions can your CPU execute in one year if the machine is left running all the time?


:[[1.29]]. A sorting algorithm takes 1 second to sort 1,000 items on your machine. How long will it take to sort 10,000 items. . .
::(a) if you believe that the algorithm takes time proportional to n2, and
::(b) if you believe that the algorithm takes time roughly proportional to n log n?


===Implementation Projects===

:1.30. Implement the two TSP heuristics of Section 1.1 (page 5). Which of them gives better solutions in practice? Can you devise a heuristic that works better than both of them?


:[[1.31]]. Describe how to test whether a given set of tickets establishes sufficient coverage in the Lotto problem of Section 1.8 (page 22). Write a program to find good ticket sets.


===Interview Problems===

:1.32. Write a function to perform integer division without using either the / or * operators. Find a fast way to do it.


:[[1.33]]. There are twenty-five horses. At most, five horses can race together at a time. You must determine the fastest, second fastest, and third fastest horses. Find the minimum number of races in which this can be done.


:1.34. How many piano tuners are there in the entire world?


:[[1.35]]. How many gas stations are there in the United States?


:1.36. How much does the ice in a hockey rink weigh?


:[[1.37]]. How many miles of road are there in the United States?


:1.38. On average, how many times would you have to flip open the Manhattan phone book at random in order to find a specific name?


Back to [[Chapter List]]</text>
      <sha1>6r9dmykba851rtsl3gu6ztu5pkhedx8</sha1>
    </revision>
    <revision>
      <id>43</id>
      <parentid>42</parentid>
      <timestamp>2020-08-31T16:57:13Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Finding Counter Examples */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="6647">=Introduction to Algorithms=

===Finding Counter Examples===

:[[1.1]]. Show that &lt;math&gt;a + b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:1.2. Show that &lt;math&gt;a \times b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:[[1.3]]. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the fastest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the shortest route.


:1.4. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the shortest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers '&lt;math&gt;S = \{s_1, s_2, \ldots, s_n\}&lt;/math&gt;, and a target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; which adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, there exists a subset within &lt;math&gt;S = \{1, 2, 5, 9, 10\}&lt;/math&gt; that adds up to &lt;math&gt;T=22&lt;/math&gt; but not &lt;math&gt;T=23&lt;/math&gt;.
:Find counterexamples to each of the following algorithms for the knapsack problem. That is, giving an &lt;math&gt;S&lt;/math&gt; and &lt;math&gt;T&lt;/math&gt; such that the subset is selected using the algorithm does not leave the knapsack completely full, even though such a solution exists.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack in left to right order if they fit, i.e. the first-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from smallest to largest, i.e. the best-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set ''S'' of subsets &lt;math&gt; S_1, ..., S_m&lt;/math&gt; of the universal set &lt;math&gt;U = \{1,...,n\}&lt;/math&gt;, find the smallest subset of subsets &lt;math&gt;T \subset S&lt;/math&gt; such that &lt;math&gt;\cup_{t_i \in T} t_i = U&lt;/math&gt;.For example, there are the following subsets, &lt;math&gt;S_1 = \{1, 3, 5\}&lt;/math&gt;, &lt;math&gt;S_2 = \{2,4\}&lt;/math&gt;, &lt;math&gt;S_3 = \{1,4\}&lt;/math&gt;, and &lt;math&gt;S_4 = \{2,5\}&lt;/math&gt; The set cover would then be &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt;.

:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph ''G'' = (''V'', ''E'') asks for the largest subset ''C'' of vertices ''V'' such that there is an edge in ''E'' between every pair of vertices in ''C''. Find a counterexample for the following algorithm: Sort the vertices of ''G'' from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.

===Proofs of Correctness===

:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants ''c'' ≥ 2.
::Multiply(''y, z'')
:::''if z'' = 0 ''then'' return(0) ''else''
:::return(Multiply(''cy'', [''z/c'']) + ''y'' · (''z'' mod ''c''))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial ''anxn + an−1xn−1 + · · · + a1x + a0''.
::Horner(''a, x'')
:::''p'' = ''an''
:::for ''i'' from ''n'' − 1 to 0
::::''p'' = ''p · x'' + ''ai''
:::return ''p''


:1.10. Prove the correctness of the following sorting algorithm.

::Bubblesort (''A'')
:::for ''i'' from ''n'' to 1
::::for ''j'' from 1 to ''i'' − 1
:::::if (''A''[''j''] &gt; ''A''[''j'' + 1])
::::::swap the values of ''A''[''j''] and ''A''[''j'' + 1]


:[[1.11]]. The ''greatest common divisor of positive'' integers ''x'' and ''y'' is the largest integer ''d'' such that ''d'' divides ''x'' and ''d'' divides ''y''. Euclid’s algorithm to compute gcd(''x, y'') where ''x'' &gt; ''y'' reduces the task to a smaller problem:

:::::gcd(''x, y'') = gcd(''y, x'' mod ''y'')

:Prove that Euclid’s algorithm is correct.


===Induction===

:1.12. 


:[[1.13]]


:1.14


:[[1.15]]


:1.16


:[[1.17]]


:1.18


:[[1.19]]


:1.20


===Estimation===

:[[1.21]]. Do all the books you own total at least one million pages? How many total pages are stored in your school library?


:1.22. How many words are there in this textbook?


:[[1.23]]. How many hours are one million seconds? How many days? Answer these questions by doing all arithmetic in your head.


:1.24. Estimate how many cities and towns there are in the United States.


:[[1.25]]. Estimate how many cubic miles of water flow out of the mouth of the Mississippi River each day. Do not look up any supplemental facts. Describe all assumptions you made in arriving at your answer.


:1.26. How many Starbucks or McDonald’s locations are there in your country?


:[[1.27]]. How long would it take to empty a bathtub with a drinking straw?


:1.28. Is disk drive access time normally measured in milliseconds (thousandths of a second) or microseconds (millionths of a second)? Does your RAM memory access a word in more or less than a microsecond? How many instructions can your CPU execute in one year if the machine is left running all the time?


:[[1.29]]. A sorting algorithm takes 1 second to sort 1,000 items on your machine. How long will it take to sort 10,000 items. . .
::(a) if you believe that the algorithm takes time proportional to n2, and
::(b) if you believe that the algorithm takes time roughly proportional to n log n?


===Implementation Projects===

:1.30. Implement the two TSP heuristics of Section 1.1 (page 5). Which of them gives better solutions in practice? Can you devise a heuristic that works better than both of them?


:[[1.31]]. Describe how to test whether a given set of tickets establishes sufficient coverage in the Lotto problem of Section 1.8 (page 22). Write a program to find good ticket sets.


===Interview Problems===

:1.32. Write a function to perform integer division without using either the / or * operators. Find a fast way to do it.


:[[1.33]]. There are twenty-five horses. At most, five horses can race together at a time. You must determine the fastest, second fastest, and third fastest horses. Find the minimum number of races in which this can be done.


:1.34. How many piano tuners are there in the entire world?


:[[1.35]]. How many gas stations are there in the United States?


:1.36. How much does the ice in a hockey rink weigh?


:[[1.37]]. How many miles of road are there in the United States?


:1.38. On average, how many times would you have to flip open the Manhattan phone book at random in order to find a specific name?


Back to [[Chapter List]]</text>
      <sha1>0kox471d6rwh7eyx0ok23vl2wl10duu</sha1>
    </revision>
    <revision>
      <id>49</id>
      <parentid>43</parentid>
      <timestamp>2020-08-31T20:18:08Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Introduction to Algorithms */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="6657">=Introduction to Algorithms=

===Finding Counter Examples===

:[[1.1]]. Show that &lt;math&gt;a + b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:1.2. Show that &lt;math&gt;a \times b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:[[1.3]]. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the fastest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the shortest route.


:1.4. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the shortest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = \{s_1, s_2, \ldots, s_n\}&lt;/math&gt;, and a target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; which adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, there exists a subset within &lt;math&gt;S = \{1, 2, 5, 9, 10\}&lt;/math&gt; that adds up to &lt;math&gt;T=22&lt;/math&gt; but not &lt;math&gt;T=23&lt;/math&gt;.
:Find counterexamples to each of the following algorithms for the knapsack problem. That is, giving an &lt;math&gt;S&lt;/math&gt; and &lt;math&gt;T&lt;/math&gt; such that the subset is selected using the algorithm does not leave the knapsack completely full, even though such a solution exists.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack in left to right order if they fit, i.e. the first-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from smallest to largest, i.e. the best-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set ''S'' of subsets &lt;math&gt; S_1, ..., S_m&lt;/math&gt; of the universal set &lt;math&gt;U = \{1,...,n\}&lt;/math&gt;, find the smallest subset of subsets &lt;math&gt;T \subset S&lt;/math&gt; such that &lt;math&gt;\cup_{t_i \in T} t_i = U&lt;/math&gt;.For example, there are the following subsets, &lt;math&gt;S_1 = \{1, 3, 5\}&lt;/math&gt;, &lt;math&gt;S_2 = \{2,4\}&lt;/math&gt;, &lt;math&gt;S_3 = \{1,4\}&lt;/math&gt;, and &lt;math&gt;S_4 = \{2,5\}&lt;/math&gt; The set cover would then be &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt;.

:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph &lt;math&gt;G'' = (''V'', ''E'')&lt;/math&gt; asks for the largest subset ''C'' of vertices ''V'' such that there is an edge in ''E'' between every pair of vertices in ''C''. Find a counterexample for the following algorithm: Sort the vertices of ''G'' from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.

===Proofs of Correctness===

:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants ''c'' ≥ 2.
::Multiply(''y, z'')
:::''if z'' = 0 ''then'' return(0) ''else''
:::return(Multiply(''cy'', [''z/c'']) + ''y'' · (''z'' mod ''c''))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial ''anxn + an−1xn−1 + · · · + a1x + a0''.
::Horner(''a, x'')
:::''p'' = ''an''
:::for ''i'' from ''n'' − 1 to 0
::::''p'' = ''p · x'' + ''ai''
:::return ''p''


:1.10. Prove the correctness of the following sorting algorithm.

::Bubblesort (''A'')
:::for ''i'' from ''n'' to 1
::::for ''j'' from 1 to ''i'' − 1
:::::if (''A''[''j''] &gt; ''A''[''j'' + 1])
::::::swap the values of ''A''[''j''] and ''A''[''j'' + 1]


:[[1.11]]. The ''greatest common divisor of positive'' integers ''x'' and ''y'' is the largest integer ''d'' such that ''d'' divides ''x'' and ''d'' divides ''y''. Euclid’s algorithm to compute gcd(''x, y'') where ''x'' &gt; ''y'' reduces the task to a smaller problem:

:::::gcd(''x, y'') = gcd(''y, x'' mod ''y'')

:Prove that Euclid’s algorithm is correct.


===Induction===

:1.12. 


:[[1.13]]


:1.14


:[[1.15]]


:1.16


:[[1.17]]


:1.18


:[[1.19]]


:1.20


===Estimation===

:[[1.21]]. Do all the books you own total at least one million pages? How many total pages are stored in your school library?


:1.22. How many words are there in this textbook?


:[[1.23]]. How many hours are one million seconds? How many days? Answer these questions by doing all arithmetic in your head.


:1.24. Estimate how many cities and towns there are in the United States.


:[[1.25]]. Estimate how many cubic miles of water flow out of the mouth of the Mississippi River each day. Do not look up any supplemental facts. Describe all assumptions you made in arriving at your answer.


:1.26. How many Starbucks or McDonald’s locations are there in your country?


:[[1.27]]. How long would it take to empty a bathtub with a drinking straw?


:1.28. Is disk drive access time normally measured in milliseconds (thousandths of a second) or microseconds (millionths of a second)? Does your RAM memory access a word in more or less than a microsecond? How many instructions can your CPU execute in one year if the machine is left running all the time?


:[[1.29]]. A sorting algorithm takes 1 second to sort 1,000 items on your machine. How long will it take to sort 10,000 items. . .
::(a) if you believe that the algorithm takes time proportional to n2, and
::(b) if you believe that the algorithm takes time roughly proportional to n log n?


===Implementation Projects===

:1.30. Implement the two TSP heuristics of Section 1.1 (page 5). Which of them gives better solutions in practice? Can you devise a heuristic that works better than both of them?


:[[1.31]]. Describe how to test whether a given set of tickets establishes sufficient coverage in the Lotto problem of Section 1.8 (page 22). Write a program to find good ticket sets.


===Interview Problems===

:1.32. Write a function to perform integer division without using either the / or * operators. Find a fast way to do it.


:[[1.33]]. There are twenty-five horses. At most, five horses can race together at a time. You must determine the fastest, second fastest, and third fastest horses. Find the minimum number of races in which this can be done.


:1.34. How many piano tuners are there in the entire world?


:[[1.35]]. How many gas stations are there in the United States?


:1.36. How much does the ice in a hockey rink weigh?


:[[1.37]]. How many miles of road are there in the United States?


:1.38. On average, how many times would you have to flip open the Manhattan phone book at random in order to find a specific name?


Back to [[Chapter List]]</text>
      <sha1>qudmbrrg7omhbdkugw7fmnl7hr0elho</sha1>
    </revision>
    <revision>
      <id>50</id>
      <parentid>49</parentid>
      <timestamp>2020-08-31T20:19:46Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Finding Counter Examples */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="6701">=Introduction to Algorithms=

===Finding Counter Examples===

:[[1.1]]. Show that &lt;math&gt;a + b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:1.2. Show that &lt;math&gt;a \times b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:[[1.3]]. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the fastest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the shortest route.


:1.4. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the shortest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = \{s_1, s_2, \ldots, s_n\}&lt;/math&gt;, and a target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; which adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, there exists a subset within &lt;math&gt;S = \{1, 2, 5, 9, 10\}&lt;/math&gt; that adds up to &lt;math&gt;T=22&lt;/math&gt; but not &lt;math&gt;T=23&lt;/math&gt;.
:Find counterexamples to each of the following algorithms for the knapsack problem. That is, giving an &lt;math&gt;S&lt;/math&gt; and &lt;math&gt;T&lt;/math&gt; such that the subset is selected using the algorithm does not leave the knapsack completely full, even though such a solution exists.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack in left to right order if they fit, i.e. the first-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from smallest to largest, i.e. the best-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set &lt;math&gt;S&lt;/math&gt; of subsets &lt;math&gt; S_1, ..., S_m&lt;/math&gt; of the universal set &lt;math&gt;U = \{1,...,n\}&lt;/math&gt;, find the smallest subset of subsets &lt;math&gt;T \subset S&lt;/math&gt; such that &lt;math&gt;\cup_{t_i \in T} t_i = U&lt;/math&gt;.For example, there are the following subsets, &lt;math&gt;S_1 = \{1, 3, 5\}&lt;/math&gt;, &lt;math&gt;S_2 = \{2,4\}&lt;/math&gt;, &lt;math&gt;S_3 = \{1,4\}&lt;/math&gt;, and &lt;math&gt;S_4 = \{2,5\}&lt;/math&gt; The set cover would then be &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt;.

:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph &lt;math&gt;G = (V, E)&lt;/math&gt; asks for the largest subset &lt;math&gt;C&lt;/math&gt; of vertices &lt;math&gt;V&lt;/math&gt; such that there is an edge in &lt;math&gt;E&lt;/math&gt; between every pair of vertices in &lt;math&gt;C&lt;/math&gt;. Find a counterexample for the following algorithm: Sort the vertices of &lt;math&gt;G&lt;/math&gt; from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.

===Proofs of Correctness===

:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants ''c'' ≥ 2.
::Multiply(''y, z'')
:::''if z'' = 0 ''then'' return(0) ''else''
:::return(Multiply(''cy'', [''z/c'']) + ''y'' · (''z'' mod ''c''))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial ''anxn + an−1xn−1 + · · · + a1x + a0''.
::Horner(''a, x'')
:::''p'' = ''an''
:::for ''i'' from ''n'' − 1 to 0
::::''p'' = ''p · x'' + ''ai''
:::return ''p''


:1.10. Prove the correctness of the following sorting algorithm.

::Bubblesort (''A'')
:::for ''i'' from ''n'' to 1
::::for ''j'' from 1 to ''i'' − 1
:::::if (''A''[''j''] &gt; ''A''[''j'' + 1])
::::::swap the values of ''A''[''j''] and ''A''[''j'' + 1]


:[[1.11]]. The ''greatest common divisor of positive'' integers ''x'' and ''y'' is the largest integer ''d'' such that ''d'' divides ''x'' and ''d'' divides ''y''. Euclid’s algorithm to compute gcd(''x, y'') where ''x'' &gt; ''y'' reduces the task to a smaller problem:

:::::gcd(''x, y'') = gcd(''y, x'' mod ''y'')

:Prove that Euclid’s algorithm is correct.


===Induction===

:1.12. 


:[[1.13]]


:1.14


:[[1.15]]


:1.16


:[[1.17]]


:1.18


:[[1.19]]


:1.20


===Estimation===

:[[1.21]]. Do all the books you own total at least one million pages? How many total pages are stored in your school library?


:1.22. How many words are there in this textbook?


:[[1.23]]. How many hours are one million seconds? How many days? Answer these questions by doing all arithmetic in your head.


:1.24. Estimate how many cities and towns there are in the United States.


:[[1.25]]. Estimate how many cubic miles of water flow out of the mouth of the Mississippi River each day. Do not look up any supplemental facts. Describe all assumptions you made in arriving at your answer.


:1.26. How many Starbucks or McDonald’s locations are there in your country?


:[[1.27]]. How long would it take to empty a bathtub with a drinking straw?


:1.28. Is disk drive access time normally measured in milliseconds (thousandths of a second) or microseconds (millionths of a second)? Does your RAM memory access a word in more or less than a microsecond? How many instructions can your CPU execute in one year if the machine is left running all the time?


:[[1.29]]. A sorting algorithm takes 1 second to sort 1,000 items on your machine. How long will it take to sort 10,000 items. . .
::(a) if you believe that the algorithm takes time proportional to n2, and
::(b) if you believe that the algorithm takes time roughly proportional to n log n?


===Implementation Projects===

:1.30. Implement the two TSP heuristics of Section 1.1 (page 5). Which of them gives better solutions in practice? Can you devise a heuristic that works better than both of them?


:[[1.31]]. Describe how to test whether a given set of tickets establishes sufficient coverage in the Lotto problem of Section 1.8 (page 22). Write a program to find good ticket sets.


===Interview Problems===

:1.32. Write a function to perform integer division without using either the / or * operators. Find a fast way to do it.


:[[1.33]]. There are twenty-five horses. At most, five horses can race together at a time. You must determine the fastest, second fastest, and third fastest horses. Find the minimum number of races in which this can be done.


:1.34. How many piano tuners are there in the entire world?


:[[1.35]]. How many gas stations are there in the United States?


:1.36. How much does the ice in a hockey rink weigh?


:[[1.37]]. How many miles of road are there in the United States?


:1.38. On average, how many times would you have to flip open the Manhattan phone book at random in order to find a specific name?


Back to [[Chapter List]]</text>
      <sha1>f5gvsz41z6iaqlwog80fcy5dngpf2gv</sha1>
    </revision>
    <revision>
      <id>51</id>
      <parentid>50</parentid>
      <timestamp>2020-08-31T20:42:52Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Proofs of Correctness */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="7166">=Introduction to Algorithms=

===Finding Counter Examples===

:[[1.1]]. Show that &lt;math&gt;a + b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:1.2. Show that &lt;math&gt;a \times b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:[[1.3]]. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the fastest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the shortest route.


:1.4. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the shortest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = \{s_1, s_2, \ldots, s_n\}&lt;/math&gt;, and a target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; which adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, there exists a subset within &lt;math&gt;S = \{1, 2, 5, 9, 10\}&lt;/math&gt; that adds up to &lt;math&gt;T=22&lt;/math&gt; but not &lt;math&gt;T=23&lt;/math&gt;.
:Find counterexamples to each of the following algorithms for the knapsack problem. That is, giving an &lt;math&gt;S&lt;/math&gt; and &lt;math&gt;T&lt;/math&gt; such that the subset is selected using the algorithm does not leave the knapsack completely full, even though such a solution exists.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack in left to right order if they fit, i.e. the first-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from smallest to largest, i.e. the best-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set &lt;math&gt;S&lt;/math&gt; of subsets &lt;math&gt; S_1, ..., S_m&lt;/math&gt; of the universal set &lt;math&gt;U = \{1,...,n\}&lt;/math&gt;, find the smallest subset of subsets &lt;math&gt;T \subset S&lt;/math&gt; such that &lt;math&gt;\cup_{t_i \in T} t_i = U&lt;/math&gt;.For example, there are the following subsets, &lt;math&gt;S_1 = \{1, 3, 5\}&lt;/math&gt;, &lt;math&gt;S_2 = \{2,4\}&lt;/math&gt;, &lt;math&gt;S_3 = \{1,4\}&lt;/math&gt;, and &lt;math&gt;S_4 = \{2,5\}&lt;/math&gt; The set cover would then be &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt;.

:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph &lt;math&gt;G = (V, E)&lt;/math&gt; asks for the largest subset &lt;math&gt;C&lt;/math&gt; of vertices &lt;math&gt;V&lt;/math&gt; such that there is an edge in &lt;math&gt;E&lt;/math&gt; between every pair of vertices in &lt;math&gt;C&lt;/math&gt;. Find a counterexample for the following algorithm: Sort the vertices of &lt;math&gt;G&lt;/math&gt; from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.

===Proofs of Correctness===

:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants &lt;math&gt; c \geq 2&lt;/math&gt;.
   ''function'' multiply(&lt;math&gt;y,z&lt;/math&gt;)
   ''comment'' Return the product &lt;math&gt;yz&lt;/math&gt;.
   1.     ''if'' &lt;math&gt;z=0&lt;/math&gt; ''then'' return(0) ''else''
   2.     return(multiply(&lt;math&gt;cy,\lfloor z/c \rfloor)+y \cdot (z\,\bmod\,c&lt;/math&gt;))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial. P(x) = &lt;math&gt;a_nx^n + a_{n-1}x^{n-1} + \dots + a_1x + a_0&lt;/math&gt;
   ''function'' horner(&lt;math&gt;A,x&lt;/math&gt;)
       &lt;math&gt;p = A_n&lt;/math&gt;
       for &lt;math&gt;i&lt;/math&gt; from &lt;math&gt;n-1&lt;/math&gt; to &lt;math&gt;0&lt;/math&gt;
               &lt;math&gt;p = p*x+A_i&lt;/math&gt;
       return &lt;math&gt;p&lt;/math&gt;

:1.10. Prove the correctness of the following sorting algorithm.
''function'' bubblesort (&lt;math&gt;A&lt;/math&gt; : list[&lt;math&gt;1 \dots n&lt;/math&gt;])
       var int &lt;math&gt;i, j&lt;/math&gt;
       for &lt;math&gt;i&lt;/math&gt; from &lt;math&gt;n&lt;/math&gt; to &lt;math&gt;1&lt;/math&gt;
           for &lt;math&gt;j&lt;/math&gt; from &lt;math&gt;1&lt;/math&gt; to &lt;math&gt;i-1&lt;/math&gt;
               if (&lt;math&gt;A[j] &gt; A[j+1]&lt;/math&gt;)
                   swap the values of &lt;math&gt;A[j]&lt;/math&gt; and &lt;math&gt;A[j+1]&lt;/math&gt;


:[[1.11]]. The ''greatest common divisor of positive'' integers &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt; is the largest integer &lt;math&gt;d&lt;/math&gt; such that &lt;math&gt;d&lt;/math&gt; divides &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;d&lt;/math&gt; divides &lt;math&gt;y&lt;/math&gt;. Euclid’s algorithm to compute gcd(x, y) where &lt;math&gt;x &gt; y&lt;/math&gt; reduces the task to a smaller problem:

:::::&lt;math&gt;&lt;gcd(x, y) = gcd(y, x mod y)/math&gt;

:Prove that Euclid’s algorithm is correct.

===Induction===

:1.12. 


:[[1.13]]


:1.14


:[[1.15]]


:1.16


:[[1.17]]


:1.18


:[[1.19]]


:1.20


===Estimation===

:[[1.21]]. Do all the books you own total at least one million pages? How many total pages are stored in your school library?


:1.22. How many words are there in this textbook?


:[[1.23]]. How many hours are one million seconds? How many days? Answer these questions by doing all arithmetic in your head.


:1.24. Estimate how many cities and towns there are in the United States.


:[[1.25]]. Estimate how many cubic miles of water flow out of the mouth of the Mississippi River each day. Do not look up any supplemental facts. Describe all assumptions you made in arriving at your answer.


:1.26. How many Starbucks or McDonald’s locations are there in your country?


:[[1.27]]. How long would it take to empty a bathtub with a drinking straw?


:1.28. Is disk drive access time normally measured in milliseconds (thousandths of a second) or microseconds (millionths of a second)? Does your RAM memory access a word in more or less than a microsecond? How many instructions can your CPU execute in one year if the machine is left running all the time?


:[[1.29]]. A sorting algorithm takes 1 second to sort 1,000 items on your machine. How long will it take to sort 10,000 items. . .
::(a) if you believe that the algorithm takes time proportional to n2, and
::(b) if you believe that the algorithm takes time roughly proportional to n log n?


===Implementation Projects===

:1.30. Implement the two TSP heuristics of Section 1.1 (page 5). Which of them gives better solutions in practice? Can you devise a heuristic that works better than both of them?


:[[1.31]]. Describe how to test whether a given set of tickets establishes sufficient coverage in the Lotto problem of Section 1.8 (page 22). Write a program to find good ticket sets.


===Interview Problems===

:1.32. Write a function to perform integer division without using either the / or * operators. Find a fast way to do it.


:[[1.33]]. There are twenty-five horses. At most, five horses can race together at a time. You must determine the fastest, second fastest, and third fastest horses. Find the minimum number of races in which this can be done.


:1.34. How many piano tuners are there in the entire world?


:[[1.35]]. How many gas stations are there in the United States?


:1.36. How much does the ice in a hockey rink weigh?


:[[1.37]]. How many miles of road are there in the United States?


:1.38. On average, how many times would you have to flip open the Manhattan phone book at random in order to find a specific name?


Back to [[Chapter List]]</text>
      <sha1>pvw4ldyj2pf1jp8mnfd4yqaqawz7qu9</sha1>
    </revision>
    <revision>
      <id>52</id>
      <parentid>51</parentid>
      <timestamp>2020-09-01T11:57:37Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Proofs of Correctness */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="7084">=Introduction to Algorithms=

===Finding Counter Examples===

:[[1.1]]. Show that &lt;math&gt;a + b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:1.2. Show that &lt;math&gt;a \times b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:[[1.3]]. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the fastest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the shortest route.


:1.4. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the shortest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = \{s_1, s_2, \ldots, s_n\}&lt;/math&gt;, and a target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; which adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, there exists a subset within &lt;math&gt;S = \{1, 2, 5, 9, 10\}&lt;/math&gt; that adds up to &lt;math&gt;T=22&lt;/math&gt; but not &lt;math&gt;T=23&lt;/math&gt;.
:Find counterexamples to each of the following algorithms for the knapsack problem. That is, giving an &lt;math&gt;S&lt;/math&gt; and &lt;math&gt;T&lt;/math&gt; such that the subset is selected using the algorithm does not leave the knapsack completely full, even though such a solution exists.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack in left to right order if they fit, i.e. the first-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from smallest to largest, i.e. the best-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set &lt;math&gt;S&lt;/math&gt; of subsets &lt;math&gt; S_1, ..., S_m&lt;/math&gt; of the universal set &lt;math&gt;U = \{1,...,n\}&lt;/math&gt;, find the smallest subset of subsets &lt;math&gt;T \subset S&lt;/math&gt; such that &lt;math&gt;\cup_{t_i \in T} t_i = U&lt;/math&gt;.For example, there are the following subsets, &lt;math&gt;S_1 = \{1, 3, 5\}&lt;/math&gt;, &lt;math&gt;S_2 = \{2,4\}&lt;/math&gt;, &lt;math&gt;S_3 = \{1,4\}&lt;/math&gt;, and &lt;math&gt;S_4 = \{2,5\}&lt;/math&gt; The set cover would then be &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt;.

:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph &lt;math&gt;G = (V, E)&lt;/math&gt; asks for the largest subset &lt;math&gt;C&lt;/math&gt; of vertices &lt;math&gt;V&lt;/math&gt; such that there is an edge in &lt;math&gt;E&lt;/math&gt; between every pair of vertices in &lt;math&gt;C&lt;/math&gt;. Find a counterexample for the following algorithm: Sort the vertices of &lt;math&gt;G&lt;/math&gt; from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.

===Proofs of Correctness===

:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants &lt;math&gt; c \geq 2&lt;/math&gt;.
   multiply(&lt;math&gt;y,z&lt;/math&gt;)
   #Return the product &lt;math&gt;yz&lt;/math&gt;.
   1.     ''if'' &lt;math&gt;z=0&lt;/math&gt; ''then'' return(0) ''else''
   2.     return(multiply(&lt;math&gt;cy,\lfloor z/c \rfloor)+y \cdot (z\,\bmod\,c&lt;/math&gt;))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial. P(x) = &lt;math&gt;a_nx^n + a_{n-1}x^{n-1} + \dots + a_1x + a_0&lt;/math&gt;
    horner(&lt;math&gt;A,x&lt;/math&gt;)
       &lt;math&gt;p = A_n&lt;/math&gt;
       for &lt;math&gt;i&lt;/math&gt; from &lt;math&gt;n-1&lt;/math&gt; to &lt;math&gt;0&lt;/math&gt;
               &lt;math&gt;p = p*x+A_i&lt;/math&gt;
       return &lt;math&gt;p&lt;/math&gt;

:1.10. Prove the correctness of the following sorting algorithm.
bubblesort (&lt;math&gt;A&lt;/math&gt; : list[&lt;math&gt;1 \dots n&lt;/math&gt;])
       for &lt;math&gt;i&lt;/math&gt; from &lt;math&gt;n&lt;/math&gt; to &lt;math&gt;1&lt;/math&gt;
           for &lt;math&gt;j&lt;/math&gt; from &lt;math&gt;1&lt;/math&gt; to &lt;math&gt;i-1&lt;/math&gt;
               if (&lt;math&gt;A[j] &gt; A[j+1]&lt;/math&gt;)
                   swap the values of &lt;math&gt;A[j]&lt;/math&gt; and &lt;math&gt;A[j+1]&lt;/math&gt;


:[[1.11]]. The ''greatest common divisor of positive'' integers &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt; is the largest integer &lt;math&gt;d&lt;/math&gt; such that &lt;math&gt;d&lt;/math&gt; divides &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;d&lt;/math&gt; divides &lt;math&gt;y&lt;/math&gt;. Euclid’s algorithm to compute gcd(x, y) where &lt;math&gt;x &gt; y&lt;/math&gt; reduces the task to a smaller problem:

:::::&lt;math&gt;&lt;gcd(x, y) = gcd(y, x mod y)/math&gt;

:Prove that Euclid’s algorithm is correct.

===Induction===

:1.12. 


:[[1.13]]


:1.14


:[[1.15]]


:1.16


:[[1.17]]


:1.18


:[[1.19]]


:1.20


===Estimation===

:[[1.21]]. Do all the books you own total at least one million pages? How many total pages are stored in your school library?


:1.22. How many words are there in this textbook?


:[[1.23]]. How many hours are one million seconds? How many days? Answer these questions by doing all arithmetic in your head.


:1.24. Estimate how many cities and towns there are in the United States.


:[[1.25]]. Estimate how many cubic miles of water flow out of the mouth of the Mississippi River each day. Do not look up any supplemental facts. Describe all assumptions you made in arriving at your answer.


:1.26. How many Starbucks or McDonald’s locations are there in your country?


:[[1.27]]. How long would it take to empty a bathtub with a drinking straw?


:1.28. Is disk drive access time normally measured in milliseconds (thousandths of a second) or microseconds (millionths of a second)? Does your RAM memory access a word in more or less than a microsecond? How many instructions can your CPU execute in one year if the machine is left running all the time?


:[[1.29]]. A sorting algorithm takes 1 second to sort 1,000 items on your machine. How long will it take to sort 10,000 items. . .
::(a) if you believe that the algorithm takes time proportional to n2, and
::(b) if you believe that the algorithm takes time roughly proportional to n log n?


===Implementation Projects===

:1.30. Implement the two TSP heuristics of Section 1.1 (page 5). Which of them gives better solutions in practice? Can you devise a heuristic that works better than both of them?


:[[1.31]]. Describe how to test whether a given set of tickets establishes sufficient coverage in the Lotto problem of Section 1.8 (page 22). Write a program to find good ticket sets.


===Interview Problems===

:1.32. Write a function to perform integer division without using either the / or * operators. Find a fast way to do it.


:[[1.33]]. There are twenty-five horses. At most, five horses can race together at a time. You must determine the fastest, second fastest, and third fastest horses. Find the minimum number of races in which this can be done.


:1.34. How many piano tuners are there in the entire world?


:[[1.35]]. How many gas stations are there in the United States?


:1.36. How much does the ice in a hockey rink weigh?


:[[1.37]]. How many miles of road are there in the United States?


:1.38. On average, how many times would you have to flip open the Manhattan phone book at random in order to find a specific name?


Back to [[Chapter List]]</text>
      <sha1>r3yeztoi182th3d2ef442m0vqx9wi9c</sha1>
    </revision>
    <revision>
      <id>53</id>
      <parentid>52</parentid>
      <timestamp>2020-09-01T11:58:49Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Proofs of Correctness */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="7083">=Introduction to Algorithms=

===Finding Counter Examples===

:[[1.1]]. Show that &lt;math&gt;a + b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:1.2. Show that &lt;math&gt;a \times b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:[[1.3]]. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the fastest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the shortest route.


:1.4. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the shortest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = \{s_1, s_2, \ldots, s_n\}&lt;/math&gt;, and a target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; which adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, there exists a subset within &lt;math&gt;S = \{1, 2, 5, 9, 10\}&lt;/math&gt; that adds up to &lt;math&gt;T=22&lt;/math&gt; but not &lt;math&gt;T=23&lt;/math&gt;.
:Find counterexamples to each of the following algorithms for the knapsack problem. That is, giving an &lt;math&gt;S&lt;/math&gt; and &lt;math&gt;T&lt;/math&gt; such that the subset is selected using the algorithm does not leave the knapsack completely full, even though such a solution exists.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack in left to right order if they fit, i.e. the first-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from smallest to largest, i.e. the best-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set &lt;math&gt;S&lt;/math&gt; of subsets &lt;math&gt; S_1, ..., S_m&lt;/math&gt; of the universal set &lt;math&gt;U = \{1,...,n\}&lt;/math&gt;, find the smallest subset of subsets &lt;math&gt;T \subset S&lt;/math&gt; such that &lt;math&gt;\cup_{t_i \in T} t_i = U&lt;/math&gt;.For example, there are the following subsets, &lt;math&gt;S_1 = \{1, 3, 5\}&lt;/math&gt;, &lt;math&gt;S_2 = \{2,4\}&lt;/math&gt;, &lt;math&gt;S_3 = \{1,4\}&lt;/math&gt;, and &lt;math&gt;S_4 = \{2,5\}&lt;/math&gt; The set cover would then be &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt;.

:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph &lt;math&gt;G = (V, E)&lt;/math&gt; asks for the largest subset &lt;math&gt;C&lt;/math&gt; of vertices &lt;math&gt;V&lt;/math&gt; such that there is an edge in &lt;math&gt;E&lt;/math&gt; between every pair of vertices in &lt;math&gt;C&lt;/math&gt;. Find a counterexample for the following algorithm: Sort the vertices of &lt;math&gt;G&lt;/math&gt; from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.

===Proofs of Correctness===

:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants &lt;math&gt; c \geq 2&lt;/math&gt;.
   multiply(&lt;math&gt;y,z&lt;/math&gt;)
   #Return the product &lt;math&gt;yz&lt;/math&gt;.
       ''if'' &lt;math&gt;z=0&lt;/math&gt; ''then'' return(0) ''else''
        return(multiply(&lt;math&gt;cy,\lfloor z/c \rfloor)+y \cdot (z\,\bmod\,c&lt;/math&gt;))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial. P(x) = &lt;math&gt;a_nx^n + a_{n-1}x^{n-1} + \dots + a_1x + a_0&lt;/math&gt;
    horner(&lt;math&gt;A,x&lt;/math&gt;)
       &lt;math&gt;p = A_n&lt;/math&gt;
       for &lt;math&gt;i&lt;/math&gt; from &lt;math&gt;n-1&lt;/math&gt; to &lt;math&gt;0&lt;/math&gt;
               &lt;math&gt;p = p*x+A_i&lt;/math&gt;
       return &lt;math&gt;p&lt;/math&gt;

:1.10. Prove the correctness of the following sorting algorithm.
    bubblesort (&lt;math&gt;A&lt;/math&gt; : list[&lt;math&gt;1 \dots n&lt;/math&gt;])
       for &lt;math&gt;i&lt;/math&gt; from &lt;math&gt;n&lt;/math&gt; to &lt;math&gt;1&lt;/math&gt;
           for &lt;math&gt;j&lt;/math&gt; from &lt;math&gt;1&lt;/math&gt; to &lt;math&gt;i-1&lt;/math&gt;
               if (&lt;math&gt;A[j] &gt; A[j+1]&lt;/math&gt;)
                   swap the values of &lt;math&gt;A[j]&lt;/math&gt; and &lt;math&gt;A[j+1]&lt;/math&gt;


:[[1.11]]. The ''greatest common divisor of positive'' integers &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt; is the largest integer &lt;math&gt;d&lt;/math&gt; such that &lt;math&gt;d&lt;/math&gt; divides &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;d&lt;/math&gt; divides &lt;math&gt;y&lt;/math&gt;. Euclid’s algorithm to compute gcd(x, y) where &lt;math&gt;x &gt; y&lt;/math&gt; reduces the task to a smaller problem:

:::::&lt;math&gt;gcd(x, y) = gcd(y, x mod y)&lt;/math&gt;

:Prove that Euclid’s algorithm is correct.

===Induction===

:1.12. 


:[[1.13]]


:1.14


:[[1.15]]


:1.16


:[[1.17]]


:1.18


:[[1.19]]


:1.20


===Estimation===

:[[1.21]]. Do all the books you own total at least one million pages? How many total pages are stored in your school library?


:1.22. How many words are there in this textbook?


:[[1.23]]. How many hours are one million seconds? How many days? Answer these questions by doing all arithmetic in your head.


:1.24. Estimate how many cities and towns there are in the United States.


:[[1.25]]. Estimate how many cubic miles of water flow out of the mouth of the Mississippi River each day. Do not look up any supplemental facts. Describe all assumptions you made in arriving at your answer.


:1.26. How many Starbucks or McDonald’s locations are there in your country?


:[[1.27]]. How long would it take to empty a bathtub with a drinking straw?


:1.28. Is disk drive access time normally measured in milliseconds (thousandths of a second) or microseconds (millionths of a second)? Does your RAM memory access a word in more or less than a microsecond? How many instructions can your CPU execute in one year if the machine is left running all the time?


:[[1.29]]. A sorting algorithm takes 1 second to sort 1,000 items on your machine. How long will it take to sort 10,000 items. . .
::(a) if you believe that the algorithm takes time proportional to n2, and
::(b) if you believe that the algorithm takes time roughly proportional to n log n?


===Implementation Projects===

:1.30. Implement the two TSP heuristics of Section 1.1 (page 5). Which of them gives better solutions in practice? Can you devise a heuristic that works better than both of them?


:[[1.31]]. Describe how to test whether a given set of tickets establishes sufficient coverage in the Lotto problem of Section 1.8 (page 22). Write a program to find good ticket sets.


===Interview Problems===

:1.32. Write a function to perform integer division without using either the / or * operators. Find a fast way to do it.


:[[1.33]]. There are twenty-five horses. At most, five horses can race together at a time. You must determine the fastest, second fastest, and third fastest horses. Find the minimum number of races in which this can be done.


:1.34. How many piano tuners are there in the entire world?


:[[1.35]]. How many gas stations are there in the United States?


:1.36. How much does the ice in a hockey rink weigh?


:[[1.37]]. How many miles of road are there in the United States?


:1.38. On average, how many times would you have to flip open the Manhattan phone book at random in order to find a specific name?


Back to [[Chapter List]]</text>
      <sha1>gtjisv5901oa6mlflu3qhz18cqzjmvb</sha1>
    </revision>
    <revision>
      <id>54</id>
      <parentid>53</parentid>
      <timestamp>2020-09-01T11:59:57Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Proofs of Correctness */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="7096">=Introduction to Algorithms=

===Finding Counter Examples===

:[[1.1]]. Show that &lt;math&gt;a + b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:1.2. Show that &lt;math&gt;a \times b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:[[1.3]]. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the fastest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the shortest route.


:1.4. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the shortest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = \{s_1, s_2, \ldots, s_n\}&lt;/math&gt;, and a target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; which adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, there exists a subset within &lt;math&gt;S = \{1, 2, 5, 9, 10\}&lt;/math&gt; that adds up to &lt;math&gt;T=22&lt;/math&gt; but not &lt;math&gt;T=23&lt;/math&gt;.
:Find counterexamples to each of the following algorithms for the knapsack problem. That is, giving an &lt;math&gt;S&lt;/math&gt; and &lt;math&gt;T&lt;/math&gt; such that the subset is selected using the algorithm does not leave the knapsack completely full, even though such a solution exists.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack in left to right order if they fit, i.e. the first-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from smallest to largest, i.e. the best-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set &lt;math&gt;S&lt;/math&gt; of subsets &lt;math&gt; S_1, ..., S_m&lt;/math&gt; of the universal set &lt;math&gt;U = \{1,...,n\}&lt;/math&gt;, find the smallest subset of subsets &lt;math&gt;T \subset S&lt;/math&gt; such that &lt;math&gt;\cup_{t_i \in T} t_i = U&lt;/math&gt;.For example, there are the following subsets, &lt;math&gt;S_1 = \{1, 3, 5\}&lt;/math&gt;, &lt;math&gt;S_2 = \{2,4\}&lt;/math&gt;, &lt;math&gt;S_3 = \{1,4\}&lt;/math&gt;, and &lt;math&gt;S_4 = \{2,5\}&lt;/math&gt; The set cover would then be &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt;.

:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph &lt;math&gt;G = (V, E)&lt;/math&gt; asks for the largest subset &lt;math&gt;C&lt;/math&gt; of vertices &lt;math&gt;V&lt;/math&gt; such that there is an edge in &lt;math&gt;E&lt;/math&gt; between every pair of vertices in &lt;math&gt;C&lt;/math&gt;. Find a counterexample for the following algorithm: Sort the vertices of &lt;math&gt;G&lt;/math&gt; from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.

===Proofs of Correctness===

:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants &lt;math&gt; c \geq 2&lt;/math&gt;.
   multiply(&lt;math&gt;y,z&lt;/math&gt;)
   #Return the product &lt;math&gt;yz&lt;/math&gt;.
       ''if'' &lt;math&gt;z=0&lt;/math&gt; ''then'' return(0) ''else''
        return(multiply(&lt;math&gt;cy,\lfloor z/c \rfloor)+y \cdot (z\,\bmod\,c&lt;/math&gt;))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial. P(x) = &lt;math&gt;a_nx^n + a_{n-1}x^{n-1} + \dots + a_1x + a_0&lt;/math&gt;
    horner(&lt;math&gt;A,x&lt;/math&gt;)
       &lt;math&gt;p = A_n&lt;/math&gt;
       for &lt;math&gt;i&lt;/math&gt; from &lt;math&gt;n-1&lt;/math&gt; to &lt;math&gt;0&lt;/math&gt;
               &lt;math&gt;p = p*x+A_i&lt;/math&gt;
       return &lt;math&gt;p&lt;/math&gt;

:1.10. Prove the correctness of the following sorting algorithm.
    bubblesort (&lt;math&gt;A&lt;/math&gt; : list[&lt;math&gt;1 \dots n&lt;/math&gt;])
       for &lt;math&gt;i&lt;/math&gt; from &lt;math&gt;n&lt;/math&gt; to &lt;math&gt;1&lt;/math&gt;
           for &lt;math&gt;j&lt;/math&gt; from &lt;math&gt;1&lt;/math&gt; to &lt;math&gt;i-1&lt;/math&gt;
               if (&lt;math&gt;A[j] &gt; A[j+1]&lt;/math&gt;)
                   swap the values of &lt;math&gt;A[j]&lt;/math&gt; and &lt;math&gt;A[j+1]&lt;/math&gt;


:[[1.11]]. The ''greatest common divisor of positive'' integers &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt; is the largest integer &lt;math&gt;d&lt;/math&gt; such that &lt;math&gt;d&lt;/math&gt; divides &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;d&lt;/math&gt; divides &lt;math&gt;y&lt;/math&gt;. Euclid’s algorithm to compute &lt;math&gt;gcd(x, y)&lt;/math&gt; where &lt;math&gt;x &gt; y&lt;/math&gt; reduces the task to a smaller problem:

:::::&lt;math&gt;gcd(x, y) = gcd(y, x mod y)&lt;/math&gt;

:Prove that Euclid’s algorithm is correct.

===Induction===

:1.12. 


:[[1.13]]


:1.14


:[[1.15]]


:1.16


:[[1.17]]


:1.18


:[[1.19]]


:1.20


===Estimation===

:[[1.21]]. Do all the books you own total at least one million pages? How many total pages are stored in your school library?


:1.22. How many words are there in this textbook?


:[[1.23]]. How many hours are one million seconds? How many days? Answer these questions by doing all arithmetic in your head.


:1.24. Estimate how many cities and towns there are in the United States.


:[[1.25]]. Estimate how many cubic miles of water flow out of the mouth of the Mississippi River each day. Do not look up any supplemental facts. Describe all assumptions you made in arriving at your answer.


:1.26. How many Starbucks or McDonald’s locations are there in your country?


:[[1.27]]. How long would it take to empty a bathtub with a drinking straw?


:1.28. Is disk drive access time normally measured in milliseconds (thousandths of a second) or microseconds (millionths of a second)? Does your RAM memory access a word in more or less than a microsecond? How many instructions can your CPU execute in one year if the machine is left running all the time?


:[[1.29]]. A sorting algorithm takes 1 second to sort 1,000 items on your machine. How long will it take to sort 10,000 items. . .
::(a) if you believe that the algorithm takes time proportional to n2, and
::(b) if you believe that the algorithm takes time roughly proportional to n log n?


===Implementation Projects===

:1.30. Implement the two TSP heuristics of Section 1.1 (page 5). Which of them gives better solutions in practice? Can you devise a heuristic that works better than both of them?


:[[1.31]]. Describe how to test whether a given set of tickets establishes sufficient coverage in the Lotto problem of Section 1.8 (page 22). Write a program to find good ticket sets.


===Interview Problems===

:1.32. Write a function to perform integer division without using either the / or * operators. Find a fast way to do it.


:[[1.33]]. There are twenty-five horses. At most, five horses can race together at a time. You must determine the fastest, second fastest, and third fastest horses. Find the minimum number of races in which this can be done.


:1.34. How many piano tuners are there in the entire world?


:[[1.35]]. How many gas stations are there in the United States?


:1.36. How much does the ice in a hockey rink weigh?


:[[1.37]]. How many miles of road are there in the United States?


:1.38. On average, how many times would you have to flip open the Manhattan phone book at random in order to find a specific name?


Back to [[Chapter List]]</text>
      <sha1>ajdgpgnn7xpqexscpdz4s4row2s4q4l</sha1>
    </revision>
    <revision>
      <id>62</id>
      <parentid>54</parentid>
      <timestamp>2020-09-01T12:12:18Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Induction */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="8163">=Introduction to Algorithms=

===Finding Counter Examples===

:[[1.1]]. Show that &lt;math&gt;a + b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:1.2. Show that &lt;math&gt;a \times b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:[[1.3]]. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the fastest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the shortest route.


:1.4. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the shortest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = \{s_1, s_2, \ldots, s_n\}&lt;/math&gt;, and a target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; which adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, there exists a subset within &lt;math&gt;S = \{1, 2, 5, 9, 10\}&lt;/math&gt; that adds up to &lt;math&gt;T=22&lt;/math&gt; but not &lt;math&gt;T=23&lt;/math&gt;.
:Find counterexamples to each of the following algorithms for the knapsack problem. That is, giving an &lt;math&gt;S&lt;/math&gt; and &lt;math&gt;T&lt;/math&gt; such that the subset is selected using the algorithm does not leave the knapsack completely full, even though such a solution exists.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack in left to right order if they fit, i.e. the first-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from smallest to largest, i.e. the best-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set &lt;math&gt;S&lt;/math&gt; of subsets &lt;math&gt; S_1, ..., S_m&lt;/math&gt; of the universal set &lt;math&gt;U = \{1,...,n\}&lt;/math&gt;, find the smallest subset of subsets &lt;math&gt;T \subset S&lt;/math&gt; such that &lt;math&gt;\cup_{t_i \in T} t_i = U&lt;/math&gt;.For example, there are the following subsets, &lt;math&gt;S_1 = \{1, 3, 5\}&lt;/math&gt;, &lt;math&gt;S_2 = \{2,4\}&lt;/math&gt;, &lt;math&gt;S_3 = \{1,4\}&lt;/math&gt;, and &lt;math&gt;S_4 = \{2,5\}&lt;/math&gt; The set cover would then be &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt;.

:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph &lt;math&gt;G = (V, E)&lt;/math&gt; asks for the largest subset &lt;math&gt;C&lt;/math&gt; of vertices &lt;math&gt;V&lt;/math&gt; such that there is an edge in &lt;math&gt;E&lt;/math&gt; between every pair of vertices in &lt;math&gt;C&lt;/math&gt;. Find a counterexample for the following algorithm: Sort the vertices of &lt;math&gt;G&lt;/math&gt; from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.

===Proofs of Correctness===

:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants &lt;math&gt; c \geq 2&lt;/math&gt;.
   multiply(&lt;math&gt;y,z&lt;/math&gt;)
   #Return the product &lt;math&gt;yz&lt;/math&gt;.
       ''if'' &lt;math&gt;z=0&lt;/math&gt; ''then'' return(0) ''else''
        return(multiply(&lt;math&gt;cy,\lfloor z/c \rfloor)+y \cdot (z\,\bmod\,c&lt;/math&gt;))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial. P(x) = &lt;math&gt;a_nx^n + a_{n-1}x^{n-1} + \dots + a_1x + a_0&lt;/math&gt;
    horner(&lt;math&gt;A,x&lt;/math&gt;)
       &lt;math&gt;p = A_n&lt;/math&gt;
       for &lt;math&gt;i&lt;/math&gt; from &lt;math&gt;n-1&lt;/math&gt; to &lt;math&gt;0&lt;/math&gt;
               &lt;math&gt;p = p*x+A_i&lt;/math&gt;
       return &lt;math&gt;p&lt;/math&gt;

:1.10. Prove the correctness of the following sorting algorithm.
    bubblesort (&lt;math&gt;A&lt;/math&gt; : list[&lt;math&gt;1 \dots n&lt;/math&gt;])
       for &lt;math&gt;i&lt;/math&gt; from &lt;math&gt;n&lt;/math&gt; to &lt;math&gt;1&lt;/math&gt;
           for &lt;math&gt;j&lt;/math&gt; from &lt;math&gt;1&lt;/math&gt; to &lt;math&gt;i-1&lt;/math&gt;
               if (&lt;math&gt;A[j] &gt; A[j+1]&lt;/math&gt;)
                   swap the values of &lt;math&gt;A[j]&lt;/math&gt; and &lt;math&gt;A[j+1]&lt;/math&gt;


:[[1.11]]. The ''greatest common divisor of positive'' integers &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt; is the largest integer &lt;math&gt;d&lt;/math&gt; such that &lt;math&gt;d&lt;/math&gt; divides &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;d&lt;/math&gt; divides &lt;math&gt;y&lt;/math&gt;. Euclid’s algorithm to compute &lt;math&gt;gcd(x, y)&lt;/math&gt; where &lt;math&gt;x &gt; y&lt;/math&gt; reduces the task to a smaller problem:

:::::&lt;math&gt;gcd(x, y) = gcd(y, x mod y)&lt;/math&gt;

:Prove that Euclid’s algorithm is correct.

===Induction===

:1.12. Prove that &lt;math&gt;\sum_{i=1}^n i&lt;/math&gt;=&lt;math&gt;n(n+1)/2&lt;/math&gt; for &lt;math&gt;n \geq 0&lt;/math&gt;, by induction.


:[[1.13]]. Prove that &lt;math&gt;\sum_{i=1}^n i^2&lt;/math&gt;=&lt;math&gt;n(n+1)(2n+1)/6&lt;/math&gt; for &lt;math&gt;n \geq\ 0&lt;/math&gt;, by induction.


:1.14. Prove that &lt;math&gt;\sum_{i=1}^n i^3&lt;/math&gt;=&lt;math&gt;n^2(n+1)^2/4&lt;/math&gt; for &lt;math&gt;n \geq 0&lt;/math&gt;, by induction.


:[[1.15]]. Prove that &lt;math&gt; \sum_{i=1}^n i(i+1)(i+2)=n(n+1)(n+2)(n+3)/4 &lt;/math&gt;


:1.16. Prove by induction on &lt;math&gt;n \geq 1&lt;/math&gt; that for every &lt;math&gt;a \neq 1&lt;/math&gt;, &lt;math&gt; \sum_{i=0}^n a^i =\frac{a^{n+1}-1}{a-1}&lt;/math&gt;} 


:[[1.17]]. Prove by induction that for &lt;math&gt;n \geq 1&lt;/math&gt;, &lt;math&gt; \sum_{i=1}^n \frac{1}{i(i+1)} = \frac{n}{n+1} &lt;/math&gt;


:1.18. Prove by induction that &lt;math&gt;n^3+2n&lt;/math&gt; is divisible by &lt;math&gt;3&lt;/math&gt; for all &lt;math&gt;n \geq 0&lt;/math&gt;.


:[[1.19]]. Prove by induction that a tree with &lt;math&gt;n&lt;/math&gt; vertices has exactly &lt;math&gt;n-1&lt;/math&gt; edges.


:1.20. Prove by mathematical induction that the sum of the cubes of the first &lt;math&gt;n&lt;/math&gt; positive integers is equal to the square of the sum of these integers, i.e. &lt;math&gt; \sum_{i=1}^n i^3 = (  \sum_{i=1}^n i )^2 &lt;/math&gt;

===Estimation===

:[[1.21]]. Do all the books you own total at least one million pages? How many total pages are stored in your school library?


:1.22. How many words are there in this textbook?


:[[1.23]]. How many hours are one million seconds? How many days? Answer these questions by doing all arithmetic in your head.


:1.24. Estimate how many cities and towns there are in the United States.


:[[1.25]]. Estimate how many cubic miles of water flow out of the mouth of the Mississippi River each day. Do not look up any supplemental facts. Describe all assumptions you made in arriving at your answer.


:1.26. How many Starbucks or McDonald’s locations are there in your country?


:[[1.27]]. How long would it take to empty a bathtub with a drinking straw?


:1.28. Is disk drive access time normally measured in milliseconds (thousandths of a second) or microseconds (millionths of a second)? Does your RAM memory access a word in more or less than a microsecond? How many instructions can your CPU execute in one year if the machine is left running all the time?


:[[1.29]]. A sorting algorithm takes 1 second to sort 1,000 items on your machine. How long will it take to sort 10,000 items. . .
::(a) if you believe that the algorithm takes time proportional to n2, and
::(b) if you believe that the algorithm takes time roughly proportional to n log n?


===Implementation Projects===

:1.30. Implement the two TSP heuristics of Section 1.1 (page 5). Which of them gives better solutions in practice? Can you devise a heuristic that works better than both of them?


:[[1.31]]. Describe how to test whether a given set of tickets establishes sufficient coverage in the Lotto problem of Section 1.8 (page 22). Write a program to find good ticket sets.


===Interview Problems===

:1.32. Write a function to perform integer division without using either the / or * operators. Find a fast way to do it.


:[[1.33]]. There are twenty-five horses. At most, five horses can race together at a time. You must determine the fastest, second fastest, and third fastest horses. Find the minimum number of races in which this can be done.


:1.34. How many piano tuners are there in the entire world?


:[[1.35]]. How many gas stations are there in the United States?


:1.36. How much does the ice in a hockey rink weigh?


:[[1.37]]. How many miles of road are there in the United States?


:1.38. On average, how many times would you have to flip open the Manhattan phone book at random in order to find a specific name?


Back to [[Chapter List]]</text>
      <sha1>11nf9ht6wz0r3ysuwpbh0mlwv7v03z4</sha1>
    </revision>
    <revision>
      <id>63</id>
      <parentid>62</parentid>
      <timestamp>2020-09-01T12:14:42Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Induction */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="8174">=Introduction to Algorithms=

===Finding Counter Examples===

:[[1.1]]. Show that &lt;math&gt;a + b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:1.2. Show that &lt;math&gt;a \times b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:[[1.3]]. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the fastest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the shortest route.


:1.4. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the shortest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = \{s_1, s_2, \ldots, s_n\}&lt;/math&gt;, and a target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; which adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, there exists a subset within &lt;math&gt;S = \{1, 2, 5, 9, 10\}&lt;/math&gt; that adds up to &lt;math&gt;T=22&lt;/math&gt; but not &lt;math&gt;T=23&lt;/math&gt;.
:Find counterexamples to each of the following algorithms for the knapsack problem. That is, giving an &lt;math&gt;S&lt;/math&gt; and &lt;math&gt;T&lt;/math&gt; such that the subset is selected using the algorithm does not leave the knapsack completely full, even though such a solution exists.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack in left to right order if they fit, i.e. the first-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from smallest to largest, i.e. the best-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set &lt;math&gt;S&lt;/math&gt; of subsets &lt;math&gt; S_1, ..., S_m&lt;/math&gt; of the universal set &lt;math&gt;U = \{1,...,n\}&lt;/math&gt;, find the smallest subset of subsets &lt;math&gt;T \subset S&lt;/math&gt; such that &lt;math&gt;\cup_{t_i \in T} t_i = U&lt;/math&gt;.For example, there are the following subsets, &lt;math&gt;S_1 = \{1, 3, 5\}&lt;/math&gt;, &lt;math&gt;S_2 = \{2,4\}&lt;/math&gt;, &lt;math&gt;S_3 = \{1,4\}&lt;/math&gt;, and &lt;math&gt;S_4 = \{2,5\}&lt;/math&gt; The set cover would then be &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt;.

:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph &lt;math&gt;G = (V, E)&lt;/math&gt; asks for the largest subset &lt;math&gt;C&lt;/math&gt; of vertices &lt;math&gt;V&lt;/math&gt; such that there is an edge in &lt;math&gt;E&lt;/math&gt; between every pair of vertices in &lt;math&gt;C&lt;/math&gt;. Find a counterexample for the following algorithm: Sort the vertices of &lt;math&gt;G&lt;/math&gt; from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.

===Proofs of Correctness===

:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants &lt;math&gt; c \geq 2&lt;/math&gt;.
   multiply(&lt;math&gt;y,z&lt;/math&gt;)
   #Return the product &lt;math&gt;yz&lt;/math&gt;.
       ''if'' &lt;math&gt;z=0&lt;/math&gt; ''then'' return(0) ''else''
        return(multiply(&lt;math&gt;cy,\lfloor z/c \rfloor)+y \cdot (z\,\bmod\,c&lt;/math&gt;))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial. P(x) = &lt;math&gt;a_nx^n + a_{n-1}x^{n-1} + \dots + a_1x + a_0&lt;/math&gt;
    horner(&lt;math&gt;A,x&lt;/math&gt;)
       &lt;math&gt;p = A_n&lt;/math&gt;
       for &lt;math&gt;i&lt;/math&gt; from &lt;math&gt;n-1&lt;/math&gt; to &lt;math&gt;0&lt;/math&gt;
               &lt;math&gt;p = p*x+A_i&lt;/math&gt;
       return &lt;math&gt;p&lt;/math&gt;

:1.10. Prove the correctness of the following sorting algorithm.
    bubblesort (&lt;math&gt;A&lt;/math&gt; : list[&lt;math&gt;1 \dots n&lt;/math&gt;])
       for &lt;math&gt;i&lt;/math&gt; from &lt;math&gt;n&lt;/math&gt; to &lt;math&gt;1&lt;/math&gt;
           for &lt;math&gt;j&lt;/math&gt; from &lt;math&gt;1&lt;/math&gt; to &lt;math&gt;i-1&lt;/math&gt;
               if (&lt;math&gt;A[j] &gt; A[j+1]&lt;/math&gt;)
                   swap the values of &lt;math&gt;A[j]&lt;/math&gt; and &lt;math&gt;A[j+1]&lt;/math&gt;


:[[1.11]]. The ''greatest common divisor of positive'' integers &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt; is the largest integer &lt;math&gt;d&lt;/math&gt; such that &lt;math&gt;d&lt;/math&gt; divides &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;d&lt;/math&gt; divides &lt;math&gt;y&lt;/math&gt;. Euclid’s algorithm to compute &lt;math&gt;gcd(x, y)&lt;/math&gt; where &lt;math&gt;x &gt; y&lt;/math&gt; reduces the task to a smaller problem:

:::::&lt;math&gt;gcd(x, y) = gcd(y, x mod y)&lt;/math&gt;

:Prove that Euclid’s algorithm is correct.

===Induction===

:1.12. Prove that &lt;math&gt;\sum_{i=1}^n i&lt;/math&gt;=&lt;math&gt;n(n+1)/2&lt;/math&gt; for &lt;math&gt;n \geq 0&lt;/math&gt;, by induction.


:[[1.13]]. Prove that &lt;math&gt;\sum_{i=1}^n i^2&lt;/math&gt;=&lt;math&gt;n(n+1)(2n+1)/6&lt;/math&gt; for &lt;math&gt;n \geq\ 0&lt;/math&gt;, by induction.


:1.14. Prove that &lt;math&gt;\sum_{i=1}^n i^3&lt;/math&gt;=&lt;math&gt;n^2(n+1)^2/4&lt;/math&gt; for &lt;math&gt;n \geq 0&lt;/math&gt;, by induction.


:[[1.15]]. Prove that &lt;math&gt; \sum_{i=1}^n i(i+1)(i+2)=n(n+1)(n+2)(n+3)/4 &lt;/math&gt;


:1.16. Prove by induction on &lt;math&gt;n \geq 1&lt;/math&gt; that for every &lt;math&gt;a \neq 1&lt;/math&gt;, &lt;math&gt; \sum_{i=0}^n a^i =\frac{a^{n+1}-1}{a-1}&lt;/math&gt;


:[[1.17]]. Prove by induction that for &lt;math&gt;n \geq 1&lt;/math&gt;, &lt;math&gt; \sum_{i=1}^n \frac{1}{i(i+1)} = \frac{n}{n+1} &lt;/math&gt;


:1.18. Prove by induction that &lt;math&gt;n^3+2n&lt;/math&gt; is divisible by &lt;math&gt;3&lt;/math&gt; for all &lt;math&gt;n \geq 0&lt;/math&gt;.


:[[1.19]]. Prove by induction that a tree with &lt;math&gt;n&lt;/math&gt; vertices has exactly &lt;math&gt;n-1&lt;/math&gt; edges.


:1.20. Prove by mathematical induction that the sum of the cubes of the first &lt;math&gt;n&lt;/math&gt; positive integers is equal to the square of the sum of these integers, i.e.

::::::::::::&lt;math&gt; \sum_{i=1}^n i^3 = (  \sum_{i=1}^n i )^2 &lt;/math&gt;

===Estimation===

:[[1.21]]. Do all the books you own total at least one million pages? How many total pages are stored in your school library?


:1.22. How many words are there in this textbook?


:[[1.23]]. How many hours are one million seconds? How many days? Answer these questions by doing all arithmetic in your head.


:1.24. Estimate how many cities and towns there are in the United States.


:[[1.25]]. Estimate how many cubic miles of water flow out of the mouth of the Mississippi River each day. Do not look up any supplemental facts. Describe all assumptions you made in arriving at your answer.


:1.26. How many Starbucks or McDonald’s locations are there in your country?


:[[1.27]]. How long would it take to empty a bathtub with a drinking straw?


:1.28. Is disk drive access time normally measured in milliseconds (thousandths of a second) or microseconds (millionths of a second)? Does your RAM memory access a word in more or less than a microsecond? How many instructions can your CPU execute in one year if the machine is left running all the time?


:[[1.29]]. A sorting algorithm takes 1 second to sort 1,000 items on your machine. How long will it take to sort 10,000 items. . .
::(a) if you believe that the algorithm takes time proportional to n2, and
::(b) if you believe that the algorithm takes time roughly proportional to n log n?


===Implementation Projects===

:1.30. Implement the two TSP heuristics of Section 1.1 (page 5). Which of them gives better solutions in practice? Can you devise a heuristic that works better than both of them?


:[[1.31]]. Describe how to test whether a given set of tickets establishes sufficient coverage in the Lotto problem of Section 1.8 (page 22). Write a program to find good ticket sets.


===Interview Problems===

:1.32. Write a function to perform integer division without using either the / or * operators. Find a fast way to do it.


:[[1.33]]. There are twenty-five horses. At most, five horses can race together at a time. You must determine the fastest, second fastest, and third fastest horses. Find the minimum number of races in which this can be done.


:1.34. How many piano tuners are there in the entire world?


:[[1.35]]. How many gas stations are there in the United States?


:1.36. How much does the ice in a hockey rink weigh?


:[[1.37]]. How many miles of road are there in the United States?


:1.38. On average, how many times would you have to flip open the Manhattan phone book at random in order to find a specific name?


Back to [[Chapter List]]</text>
      <sha1>irecl6qtgok44mqt5n1ecqks7emrlyo</sha1>
    </revision>
    <revision>
      <id>65</id>
      <parentid>63</parentid>
      <timestamp>2020-09-01T12:16:25Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Proofs of Correctness */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="8175">=Introduction to Algorithms=

===Finding Counter Examples===

:[[1.1]]. Show that &lt;math&gt;a + b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:1.2. Show that &lt;math&gt;a \times b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:[[1.3]]. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the fastest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the shortest route.


:1.4. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the shortest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = \{s_1, s_2, \ldots, s_n\}&lt;/math&gt;, and a target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; which adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, there exists a subset within &lt;math&gt;S = \{1, 2, 5, 9, 10\}&lt;/math&gt; that adds up to &lt;math&gt;T=22&lt;/math&gt; but not &lt;math&gt;T=23&lt;/math&gt;.
:Find counterexamples to each of the following algorithms for the knapsack problem. That is, giving an &lt;math&gt;S&lt;/math&gt; and &lt;math&gt;T&lt;/math&gt; such that the subset is selected using the algorithm does not leave the knapsack completely full, even though such a solution exists.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack in left to right order if they fit, i.e. the first-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from smallest to largest, i.e. the best-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set &lt;math&gt;S&lt;/math&gt; of subsets &lt;math&gt; S_1, ..., S_m&lt;/math&gt; of the universal set &lt;math&gt;U = \{1,...,n\}&lt;/math&gt;, find the smallest subset of subsets &lt;math&gt;T \subset S&lt;/math&gt; such that &lt;math&gt;\cup_{t_i \in T} t_i = U&lt;/math&gt;.For example, there are the following subsets, &lt;math&gt;S_1 = \{1, 3, 5\}&lt;/math&gt;, &lt;math&gt;S_2 = \{2,4\}&lt;/math&gt;, &lt;math&gt;S_3 = \{1,4\}&lt;/math&gt;, and &lt;math&gt;S_4 = \{2,5\}&lt;/math&gt; The set cover would then be &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt;.

:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph &lt;math&gt;G = (V, E)&lt;/math&gt; asks for the largest subset &lt;math&gt;C&lt;/math&gt; of vertices &lt;math&gt;V&lt;/math&gt; such that there is an edge in &lt;math&gt;E&lt;/math&gt; between every pair of vertices in &lt;math&gt;C&lt;/math&gt;. Find a counterexample for the following algorithm: Sort the vertices of &lt;math&gt;G&lt;/math&gt; from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.

===Proofs of Correctness===

:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants &lt;math&gt; c \geq 2&lt;/math&gt;.
   multiply(&lt;math&gt;y,z&lt;/math&gt;)
   #Return the product &lt;math&gt;yz&lt;/math&gt;.
       ''if'' &lt;math&gt;z=0&lt;/math&gt; ''then'' return(0) ''else''
        return(multiply(&lt;math&gt;cy,\lfloor z/c \rfloor)+y \cdot (z\,\bmod\,c&lt;/math&gt;))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial. P(x) = &lt;math&gt;a_nx^n + a_{n-1}x^{n-1} + \dots + a_1x + a_0&lt;/math&gt;
    horner(&lt;math&gt;A,x&lt;/math&gt;)
       &lt;math&gt;p = A_n&lt;/math&gt;
       for &lt;math&gt;i&lt;/math&gt; from &lt;math&gt;n-1&lt;/math&gt; to &lt;math&gt;0&lt;/math&gt;
               &lt;math&gt;p = p*x+A_i&lt;/math&gt;
       return &lt;math&gt;p&lt;/math&gt;


:1.10. Prove the correctness of the following sorting algorithm.
    bubblesort (&lt;math&gt;A&lt;/math&gt; : list[&lt;math&gt;1 \dots n&lt;/math&gt;])
       for &lt;math&gt;i&lt;/math&gt; from &lt;math&gt;n&lt;/math&gt; to &lt;math&gt;1&lt;/math&gt;
           for &lt;math&gt;j&lt;/math&gt; from &lt;math&gt;1&lt;/math&gt; to &lt;math&gt;i-1&lt;/math&gt;
               if (&lt;math&gt;A[j] &gt; A[j+1]&lt;/math&gt;)
                   swap the values of &lt;math&gt;A[j]&lt;/math&gt; and &lt;math&gt;A[j+1]&lt;/math&gt;


:[[1.11]]. The ''greatest common divisor of positive'' integers &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt; is the largest integer &lt;math&gt;d&lt;/math&gt; such that &lt;math&gt;d&lt;/math&gt; divides &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;d&lt;/math&gt; divides &lt;math&gt;y&lt;/math&gt;. Euclid’s algorithm to compute &lt;math&gt;gcd(x, y)&lt;/math&gt; where &lt;math&gt;x &gt; y&lt;/math&gt; reduces the task to a smaller problem:

:::::&lt;math&gt;gcd(x, y) = gcd(y, x mod y)&lt;/math&gt;

:Prove that Euclid’s algorithm is correct.

===Induction===

:1.12. Prove that &lt;math&gt;\sum_{i=1}^n i&lt;/math&gt;=&lt;math&gt;n(n+1)/2&lt;/math&gt; for &lt;math&gt;n \geq 0&lt;/math&gt;, by induction.


:[[1.13]]. Prove that &lt;math&gt;\sum_{i=1}^n i^2&lt;/math&gt;=&lt;math&gt;n(n+1)(2n+1)/6&lt;/math&gt; for &lt;math&gt;n \geq\ 0&lt;/math&gt;, by induction.


:1.14. Prove that &lt;math&gt;\sum_{i=1}^n i^3&lt;/math&gt;=&lt;math&gt;n^2(n+1)^2/4&lt;/math&gt; for &lt;math&gt;n \geq 0&lt;/math&gt;, by induction.


:[[1.15]]. Prove that &lt;math&gt; \sum_{i=1}^n i(i+1)(i+2)=n(n+1)(n+2)(n+3)/4 &lt;/math&gt;


:1.16. Prove by induction on &lt;math&gt;n \geq 1&lt;/math&gt; that for every &lt;math&gt;a \neq 1&lt;/math&gt;, &lt;math&gt; \sum_{i=0}^n a^i =\frac{a^{n+1}-1}{a-1}&lt;/math&gt;


:[[1.17]]. Prove by induction that for &lt;math&gt;n \geq 1&lt;/math&gt;, &lt;math&gt; \sum_{i=1}^n \frac{1}{i(i+1)} = \frac{n}{n+1} &lt;/math&gt;


:1.18. Prove by induction that &lt;math&gt;n^3+2n&lt;/math&gt; is divisible by &lt;math&gt;3&lt;/math&gt; for all &lt;math&gt;n \geq 0&lt;/math&gt;.


:[[1.19]]. Prove by induction that a tree with &lt;math&gt;n&lt;/math&gt; vertices has exactly &lt;math&gt;n-1&lt;/math&gt; edges.


:1.20. Prove by mathematical induction that the sum of the cubes of the first &lt;math&gt;n&lt;/math&gt; positive integers is equal to the square of the sum of these integers, i.e.

::::::::::::&lt;math&gt; \sum_{i=1}^n i^3 = (  \sum_{i=1}^n i )^2 &lt;/math&gt;

===Estimation===

:[[1.21]]. Do all the books you own total at least one million pages? How many total pages are stored in your school library?


:1.22. How many words are there in this textbook?


:[[1.23]]. How many hours are one million seconds? How many days? Answer these questions by doing all arithmetic in your head.


:1.24. Estimate how many cities and towns there are in the United States.


:[[1.25]]. Estimate how many cubic miles of water flow out of the mouth of the Mississippi River each day. Do not look up any supplemental facts. Describe all assumptions you made in arriving at your answer.


:1.26. How many Starbucks or McDonald’s locations are there in your country?


:[[1.27]]. How long would it take to empty a bathtub with a drinking straw?


:1.28. Is disk drive access time normally measured in milliseconds (thousandths of a second) or microseconds (millionths of a second)? Does your RAM memory access a word in more or less than a microsecond? How many instructions can your CPU execute in one year if the machine is left running all the time?


:[[1.29]]. A sorting algorithm takes 1 second to sort 1,000 items on your machine. How long will it take to sort 10,000 items. . .
::(a) if you believe that the algorithm takes time proportional to n2, and
::(b) if you believe that the algorithm takes time roughly proportional to n log n?


===Implementation Projects===

:1.30. Implement the two TSP heuristics of Section 1.1 (page 5). Which of them gives better solutions in practice? Can you devise a heuristic that works better than both of them?


:[[1.31]]. Describe how to test whether a given set of tickets establishes sufficient coverage in the Lotto problem of Section 1.8 (page 22). Write a program to find good ticket sets.


===Interview Problems===

:1.32. Write a function to perform integer division without using either the / or * operators. Find a fast way to do it.


:[[1.33]]. There are twenty-five horses. At most, five horses can race together at a time. You must determine the fastest, second fastest, and third fastest horses. Find the minimum number of races in which this can be done.


:1.34. How many piano tuners are there in the entire world?


:[[1.35]]. How many gas stations are there in the United States?


:1.36. How much does the ice in a hockey rink weigh?


:[[1.37]]. How many miles of road are there in the United States?


:1.38. On average, how many times would you have to flip open the Manhattan phone book at random in order to find a specific name?


Back to [[Chapter List]]</text>
      <sha1>jra8x26fq2qzgy1of9kcvuzmny2jp50</sha1>
    </revision>
    <revision>
      <id>74</id>
      <parentid>65</parentid>
      <timestamp>2020-09-01T12:29:05Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="8393">Below are the exercises at the end of chapter 1 of the third edition of the Algorithm Design Manual by Steven Skiena. Student proposed answers to odd number questions are available by clicking on the question number.

=Introduction to Algorithms=

===Finding Counter Examples===

:[[1.1]]. Show that &lt;math&gt;a + b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:1.2. Show that &lt;math&gt;a \times b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:[[1.3]]. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the fastest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the shortest route.


:1.4. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the shortest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = \{s_1, s_2, \ldots, s_n\}&lt;/math&gt;, and a target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; which adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, there exists a subset within &lt;math&gt;S = \{1, 2, 5, 9, 10\}&lt;/math&gt; that adds up to &lt;math&gt;T=22&lt;/math&gt; but not &lt;math&gt;T=23&lt;/math&gt;.
:Find counterexamples to each of the following algorithms for the knapsack problem. That is, giving an &lt;math&gt;S&lt;/math&gt; and &lt;math&gt;T&lt;/math&gt; such that the subset is selected using the algorithm does not leave the knapsack completely full, even though such a solution exists.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack in left to right order if they fit, i.e. the first-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from smallest to largest, i.e. the best-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from largest to smallest.


:1.6. The ''set cover problem'' is as follows: given a set &lt;math&gt;S&lt;/math&gt; of subsets &lt;math&gt; S_1, ..., S_m&lt;/math&gt; of the universal set &lt;math&gt;U = \{1,...,n\}&lt;/math&gt;, find the smallest subset of subsets &lt;math&gt;T \subset S&lt;/math&gt; such that &lt;math&gt;\cup_{t_i \in T} t_i = U&lt;/math&gt;.For example, there are the following subsets, &lt;math&gt;S_1 = \{1, 3, 5\}&lt;/math&gt;, &lt;math&gt;S_2 = \{2,4\}&lt;/math&gt;, &lt;math&gt;S_3 = \{1,4\}&lt;/math&gt;, and &lt;math&gt;S_4 = \{2,5\}&lt;/math&gt; The set cover would then be &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt;.

:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph &lt;math&gt;G = (V, E)&lt;/math&gt; asks for the largest subset &lt;math&gt;C&lt;/math&gt; of vertices &lt;math&gt;V&lt;/math&gt; such that there is an edge in &lt;math&gt;E&lt;/math&gt; between every pair of vertices in &lt;math&gt;C&lt;/math&gt;. Find a counterexample for the following algorithm: Sort the vertices of &lt;math&gt;G&lt;/math&gt; from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.

===Proofs of Correctness===

:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants &lt;math&gt; c \geq 2&lt;/math&gt;.
   multiply(&lt;math&gt;y,z&lt;/math&gt;)
   #Return the product &lt;math&gt;yz&lt;/math&gt;.
       ''if'' &lt;math&gt;z=0&lt;/math&gt; ''then'' return(0) ''else''
        return(multiply(&lt;math&gt;cy,\lfloor z/c \rfloor)+y \cdot (z\,\bmod\,c&lt;/math&gt;))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial. P(x) = &lt;math&gt;a_nx^n + a_{n-1}x^{n-1} + \dots + a_1x + a_0&lt;/math&gt;
    horner(&lt;math&gt;A,x&lt;/math&gt;)
       &lt;math&gt;p = A_n&lt;/math&gt;
       for &lt;math&gt;i&lt;/math&gt; from &lt;math&gt;n-1&lt;/math&gt; to &lt;math&gt;0&lt;/math&gt;
               &lt;math&gt;p = p*x+A_i&lt;/math&gt;
       return &lt;math&gt;p&lt;/math&gt;


:1.10. Prove the correctness of the following sorting algorithm.
    bubblesort (&lt;math&gt;A&lt;/math&gt; : list[&lt;math&gt;1 \dots n&lt;/math&gt;])
       for &lt;math&gt;i&lt;/math&gt; from &lt;math&gt;n&lt;/math&gt; to &lt;math&gt;1&lt;/math&gt;
           for &lt;math&gt;j&lt;/math&gt; from &lt;math&gt;1&lt;/math&gt; to &lt;math&gt;i-1&lt;/math&gt;
               if (&lt;math&gt;A[j] &gt; A[j+1]&lt;/math&gt;)
                   swap the values of &lt;math&gt;A[j]&lt;/math&gt; and &lt;math&gt;A[j+1]&lt;/math&gt;


:[[1.11]]. The ''greatest common divisor of positive'' integers &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt; is the largest integer &lt;math&gt;d&lt;/math&gt; such that &lt;math&gt;d&lt;/math&gt; divides &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;d&lt;/math&gt; divides &lt;math&gt;y&lt;/math&gt;. Euclid’s algorithm to compute &lt;math&gt;gcd(x, y)&lt;/math&gt; where &lt;math&gt;x &gt; y&lt;/math&gt; reduces the task to a smaller problem:

:::::&lt;math&gt;gcd(x, y) = gcd(y, x mod y)&lt;/math&gt;

:Prove that Euclid’s algorithm is correct.

===Induction===

:1.12. Prove that &lt;math&gt;\sum_{i=1}^n i&lt;/math&gt;=&lt;math&gt;n(n+1)/2&lt;/math&gt; for &lt;math&gt;n \geq 0&lt;/math&gt;, by induction.


:[[1.13]]. Prove that &lt;math&gt;\sum_{i=1}^n i^2&lt;/math&gt;=&lt;math&gt;n(n+1)(2n+1)/6&lt;/math&gt; for &lt;math&gt;n \geq\ 0&lt;/math&gt;, by induction.


:1.14. Prove that &lt;math&gt;\sum_{i=1}^n i^3&lt;/math&gt;=&lt;math&gt;n^2(n+1)^2/4&lt;/math&gt; for &lt;math&gt;n \geq 0&lt;/math&gt;, by induction.


:[[1.15]]. Prove that &lt;math&gt; \sum_{i=1}^n i(i+1)(i+2)=n(n+1)(n+2)(n+3)/4 &lt;/math&gt;


:1.16. Prove by induction on &lt;math&gt;n \geq 1&lt;/math&gt; that for every &lt;math&gt;a \neq 1&lt;/math&gt;, &lt;math&gt; \sum_{i=0}^n a^i =\frac{a^{n+1}-1}{a-1}&lt;/math&gt;


:[[1.17]]. Prove by induction that for &lt;math&gt;n \geq 1&lt;/math&gt;, &lt;math&gt; \sum_{i=1}^n \frac{1}{i(i+1)} = \frac{n}{n+1} &lt;/math&gt;


:1.18. Prove by induction that &lt;math&gt;n^3+2n&lt;/math&gt; is divisible by &lt;math&gt;3&lt;/math&gt; for all &lt;math&gt;n \geq 0&lt;/math&gt;.


:[[1.19]]. Prove by induction that a tree with &lt;math&gt;n&lt;/math&gt; vertices has exactly &lt;math&gt;n-1&lt;/math&gt; edges.


:1.20. Prove by mathematical induction that the sum of the cubes of the first &lt;math&gt;n&lt;/math&gt; positive integers is equal to the square of the sum of these integers, i.e.

::::::::::::&lt;math&gt; \sum_{i=1}^n i^3 = (  \sum_{i=1}^n i )^2 &lt;/math&gt;

===Estimation===

:[[1.21]]. Do all the books you own total at least one million pages? How many total pages are stored in your school library?


:1.22. How many words are there in this textbook?


:[[1.23]]. How many hours are one million seconds? How many days? Answer these questions by doing all arithmetic in your head.


:1.24. Estimate how many cities and towns there are in the United States.


:[[1.25]]. Estimate how many cubic miles of water flow out of the mouth of the Mississippi River each day. Do not look up any supplemental facts. Describe all assumptions you made in arriving at your answer.


:1.26. How many Starbucks or McDonald’s locations are there in your country?


:[[1.27]]. How long would it take to empty a bathtub with a drinking straw?


:1.28. Is disk drive access time normally measured in milliseconds (thousandths of a second) or microseconds (millionths of a second)? Does your RAM memory access a word in more or less than a microsecond? How many instructions can your CPU execute in one year if the machine is left running all the time?


:[[1.29]]. A sorting algorithm takes 1 second to sort 1,000 items on your machine. How long will it take to sort 10,000 items. . .
::(a) if you believe that the algorithm takes time proportional to n2, and
::(b) if you believe that the algorithm takes time roughly proportional to n log n?


===Implementation Projects===

:1.30. Implement the two TSP heuristics of Section 1.1 (page 5). Which of them gives better solutions in practice? Can you devise a heuristic that works better than both of them?


:[[1.31]]. Describe how to test whether a given set of tickets establishes sufficient coverage in the Lotto problem of Section 1.8 (page 22). Write a program to find good ticket sets.


===Interview Problems===

:1.32. Write a function to perform integer division without using either the / or * operators. Find a fast way to do it.


:[[1.33]]. There are twenty-five horses. At most, five horses can race together at a time. You must determine the fastest, second fastest, and third fastest horses. Find the minimum number of races in which this can be done.


:1.34. How many piano tuners are there in the entire world?


:[[1.35]]. How many gas stations are there in the United States?


:1.36. How much does the ice in a hockey rink weigh?


:[[1.37]]. How many miles of road are there in the United States?


:1.38. On average, how many times would you have to flip open the Manhattan phone book at random in order to find a specific name?


Back to [[Chapter List]]</text>
      <sha1>oz87w4u22hhp6dm8m6lhitk5s6r3qga</sha1>
    </revision>
    <revision>
      <id>75</id>
      <parentid>74</parentid>
      <timestamp>2020-09-02T16:10:08Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Introduction to Algorithms */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="8771">Below are the exercises at the end of chapter 1 of the third edition of the Algorithm Design Manual by Steven Skiena. Student proposed answers to odd number questions are available by clicking on the question number.

=Introduction to Algorithms=

===Finding Counter Examples===

:[[1.1]]. Show that &lt;math&gt;a + b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.
::[[1.1|Solution]]


:1.2. Show that &lt;math&gt;a \times b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:[[1.3]]. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the fastest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the shortest route.
::[[1.3|Solution]]


:1.4. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the shortest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = \{s_1, s_2, \ldots, s_n\}&lt;/math&gt;, and a target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; which adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, there exists a subset within &lt;math&gt;S = \{1, 2, 5, 9, 10\}&lt;/math&gt; that adds up to &lt;math&gt;T=22&lt;/math&gt; but not &lt;math&gt;T=23&lt;/math&gt;.
:Find counterexamples to each of the following algorithms for the knapsack problem. That is, giving an &lt;math&gt;S&lt;/math&gt; and &lt;math&gt;T&lt;/math&gt; such that the subset is selected using the algorithm does not leave the knapsack completely full, even though such a solution exists.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack in left to right order if they fit, i.e. the first-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from smallest to largest, i.e. the best-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from largest to smallest.
::[[1.5|Solution]]


:1.6. The ''set cover problem'' is as follows: given a set &lt;math&gt;S&lt;/math&gt; of subsets &lt;math&gt; S_1, ..., S_m&lt;/math&gt; of the universal set &lt;math&gt;U = \{1,...,n\}&lt;/math&gt;, find the smallest subset of subsets &lt;math&gt;T \subset S&lt;/math&gt; such that &lt;math&gt;\cup_{t_i \in T} t_i = U&lt;/math&gt;.For example, there are the following subsets, &lt;math&gt;S_1 = \{1, 3, 5\}&lt;/math&gt;, &lt;math&gt;S_2 = \{2,4\}&lt;/math&gt;, &lt;math&gt;S_3 = \{1,4\}&lt;/math&gt;, and &lt;math&gt;S_4 = \{2,5\}&lt;/math&gt; The set cover would then be &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt;.

:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph &lt;math&gt;G = (V, E)&lt;/math&gt; asks for the largest subset &lt;math&gt;C&lt;/math&gt; of vertices &lt;math&gt;V&lt;/math&gt; such that there is an edge in &lt;math&gt;E&lt;/math&gt; between every pair of vertices in &lt;math&gt;C&lt;/math&gt;. Find a counterexample for the following algorithm: Sort the vertices of &lt;math&gt;G&lt;/math&gt; from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.
::[[1.7|Solution]]


===Proofs of Correctness===

:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants &lt;math&gt; c \geq 2&lt;/math&gt;.
   multiply(&lt;math&gt;y,z&lt;/math&gt;)
   #Return the product &lt;math&gt;yz&lt;/math&gt;.
       ''if'' &lt;math&gt;z=0&lt;/math&gt; ''then'' return(0) ''else''
        return(multiply(&lt;math&gt;cy,\lfloor z/c \rfloor)+y \cdot (z\,\bmod\,c&lt;/math&gt;))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial. P(x) = &lt;math&gt;a_nx^n + a_{n-1}x^{n-1} + \dots + a_1x + a_0&lt;/math&gt;
    horner(&lt;math&gt;A,x&lt;/math&gt;)
       &lt;math&gt;p = A_n&lt;/math&gt;
       for &lt;math&gt;i&lt;/math&gt; from &lt;math&gt;n-1&lt;/math&gt; to &lt;math&gt;0&lt;/math&gt;
               &lt;math&gt;p = p*x+A_i&lt;/math&gt;
       return &lt;math&gt;p&lt;/math&gt;
::[[1.9|Solution]]


:1.10. Prove the correctness of the following sorting algorithm.
    bubblesort (&lt;math&gt;A&lt;/math&gt; : list[&lt;math&gt;1 \dots n&lt;/math&gt;])
       for &lt;math&gt;i&lt;/math&gt; from &lt;math&gt;n&lt;/math&gt; to &lt;math&gt;1&lt;/math&gt;
           for &lt;math&gt;j&lt;/math&gt; from &lt;math&gt;1&lt;/math&gt; to &lt;math&gt;i-1&lt;/math&gt;
               if (&lt;math&gt;A[j] &gt; A[j+1]&lt;/math&gt;)
                   swap the values of &lt;math&gt;A[j]&lt;/math&gt; and &lt;math&gt;A[j+1]&lt;/math&gt;


:[[1.11]]. The ''greatest common divisor of positive'' integers &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt; is the largest integer &lt;math&gt;d&lt;/math&gt; such that &lt;math&gt;d&lt;/math&gt; divides &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;d&lt;/math&gt; divides &lt;math&gt;y&lt;/math&gt;. Euclid’s algorithm to compute &lt;math&gt;gcd(x, y)&lt;/math&gt; where &lt;math&gt;x &gt; y&lt;/math&gt; reduces the task to a smaller problem:

:::::&lt;math&gt;gcd(x, y) = gcd(y, x mod y)&lt;/math&gt;

:Prove that Euclid’s algorithm is correct.
::[[1.11|Solution]]


===Induction===

:1.12. Prove that &lt;math&gt;\sum_{i=1}^n i&lt;/math&gt;=&lt;math&gt;n(n+1)/2&lt;/math&gt; for &lt;math&gt;n \geq 0&lt;/math&gt;, by induction.


:[[1.13]]. Prove that &lt;math&gt;\sum_{i=1}^n i^2&lt;/math&gt;=&lt;math&gt;n(n+1)(2n+1)/6&lt;/math&gt; for &lt;math&gt;n \geq\ 0&lt;/math&gt;, by induction.
::[[1.13|Solution]]


:1.14. Prove that &lt;math&gt;\sum_{i=1}^n i^3&lt;/math&gt;=&lt;math&gt;n^2(n+1)^2/4&lt;/math&gt; for &lt;math&gt;n \geq 0&lt;/math&gt;, by induction.


:[[1.15]]. Prove that &lt;math&gt; \sum_{i=1}^n i(i+1)(i+2)=n(n+1)(n+2)(n+3)/4 &lt;/math&gt;
::[[1.15|Solution]]


:1.16. Prove by induction on &lt;math&gt;n \geq 1&lt;/math&gt; that for every &lt;math&gt;a \neq 1&lt;/math&gt;, &lt;math&gt; \sum_{i=0}^n a^i =\frac{a^{n+1}-1}{a-1}&lt;/math&gt;


:[[1.17]]. Prove by induction that for &lt;math&gt;n \geq 1&lt;/math&gt;, &lt;math&gt; \sum_{i=1}^n \frac{1}{i(i+1)} = \frac{n}{n+1} &lt;/math&gt;
::[[1.17|Solution]]


:1.18. Prove by induction that &lt;math&gt;n^3+2n&lt;/math&gt; is divisible by &lt;math&gt;3&lt;/math&gt; for all &lt;math&gt;n \geq 0&lt;/math&gt;.


:[[1.19]]. Prove by induction that a tree with &lt;math&gt;n&lt;/math&gt; vertices has exactly &lt;math&gt;n-1&lt;/math&gt; edges.
::[[1.19|Solution]]


:1.20. Prove by mathematical induction that the sum of the cubes of the first &lt;math&gt;n&lt;/math&gt; positive integers is equal to the square of the sum of these integers, i.e.

::::::::::::&lt;math&gt; \sum_{i=1}^n i^3 = (  \sum_{i=1}^n i )^2 &lt;/math&gt;


===Estimation===

:[[1.21]]. Do all the books you own total at least one million pages? How many total pages are stored in your school library?
::[[1.21|Solution]]


:1.22. How many words are there in this textbook?


:[[1.23]]. How many hours are one million seconds? How many days? Answer these questions by doing all arithmetic in your head.
::[[1.23|Solution]]


:1.24. Estimate how many cities and towns there are in the United States.


:[[1.25]]. Estimate how many cubic miles of water flow out of the mouth of the Mississippi River each day. Do not look up any supplemental facts. Describe all assumptions you made in arriving at your answer.
::[[1.25|Solution]]


:1.26. How many Starbucks or McDonald’s locations are there in your country?


:[[1.27]]. How long would it take to empty a bathtub with a drinking straw?
::[[1.27|Solution]]


:1.28. Is disk drive access time normally measured in milliseconds (thousandths of a second) or microseconds (millionths of a second)? Does your RAM memory access a word in more or less than a microsecond? How many instructions can your CPU execute in one year if the machine is left running all the time?


:[[1.29]]. A sorting algorithm takes 1 second to sort 1,000 items on your machine. How long will it take to sort 10,000 items. . .
::(a) if you believe that the algorithm takes time proportional to n2, and
::(b) if you believe that the algorithm takes time roughly proportional to n log n?
::[[1.29|Solution]]


===Implementation Projects===

:1.30. Implement the two TSP heuristics of Section 1.1 (page 5). Which of them gives better solutions in practice? Can you devise a heuristic that works better than both of them?


:[[1.31]]. Describe how to test whether a given set of tickets establishes sufficient coverage in the Lotto problem of Section 1.8 (page 22). Write a program to find good ticket sets.
::[[1.31|Solution]]


===Interview Problems===

:1.32. Write a function to perform integer division without using either the / or * operators. Find a fast way to do it.


:[[1.33]]. There are twenty-five horses. At most, five horses can race together at a time. You must determine the fastest, second fastest, and third fastest horses. Find the minimum number of races in which this can be done.
::[[1.33|Solution]]


:1.34. How many piano tuners are there in the entire world?


:[[1.35]]. How many gas stations are there in the United States?
::[[1.35|Solution]]


:1.36. How much does the ice in a hockey rink weigh?


:[[1.37]]. How many miles of road are there in the United States?
::[[1.37|Solution]]


:1.38. On average, how many times would you have to flip open the Manhattan phone book at random in order to find a specific name?


Back to [[Chapter List]]</text>
      <sha1>5j4o59ow9jnk5gipktpa70iq5oo3r9k</sha1>
    </revision>
    <revision>
      <id>162</id>
      <parentid>75</parentid>
      <timestamp>2020-09-10T20:17:10Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="8733">Below are the exercises at the end of chapter 1 of the third edition of the Algorithm Design Manual by Steven Skiena. Student proposed answers to odd number questions are available by clicking on the question number.

=Introduction to Algorithms=

===Finding Counter Examples===

:[[1.1]]. Show that &lt;math&gt;a + b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.
[[1.1|Solution]]


:1.2. Show that &lt;math&gt;a \times b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:[[1.3]]. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the fastest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the shortest route.
[[1.3|Solution]]


:1.4. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the shortest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = \{s_1, s_2, \ldots, s_n\}&lt;/math&gt;, and a target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; which adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, there exists a subset within &lt;math&gt;S = \{1, 2, 5, 9, 10\}&lt;/math&gt; that adds up to &lt;math&gt;T=22&lt;/math&gt; but not &lt;math&gt;T=23&lt;/math&gt;.
:Find counterexamples to each of the following algorithms for the knapsack problem. That is, giving an &lt;math&gt;S&lt;/math&gt; and &lt;math&gt;T&lt;/math&gt; such that the subset is selected using the algorithm does not leave the knapsack completely full, even though such a solution exists.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack in left to right order if they fit, i.e. the first-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from smallest to largest, i.e. the best-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from largest to smallest.
[[1.5|Solution]]


:1.6. The ''set cover problem'' is as follows: given a set &lt;math&gt;S&lt;/math&gt; of subsets &lt;math&gt; S_1, ..., S_m&lt;/math&gt; of the universal set &lt;math&gt;U = \{1,...,n\}&lt;/math&gt;, find the smallest subset of subsets &lt;math&gt;T \subset S&lt;/math&gt; such that &lt;math&gt;\cup_{t_i \in T} t_i = U&lt;/math&gt;.For example, there are the following subsets, &lt;math&gt;S_1 = \{1, 3, 5\}&lt;/math&gt;, &lt;math&gt;S_2 = \{2,4\}&lt;/math&gt;, &lt;math&gt;S_3 = \{1,4\}&lt;/math&gt;, and &lt;math&gt;S_4 = \{2,5\}&lt;/math&gt; The set cover would then be &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt;.

:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph &lt;math&gt;G = (V, E)&lt;/math&gt; asks for the largest subset &lt;math&gt;C&lt;/math&gt; of vertices &lt;math&gt;V&lt;/math&gt; such that there is an edge in &lt;math&gt;E&lt;/math&gt; between every pair of vertices in &lt;math&gt;C&lt;/math&gt;. Find a counterexample for the following algorithm: Sort the vertices of &lt;math&gt;G&lt;/math&gt; from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.
[[1.7|Solution]]


===Proofs of Correctness===

:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants &lt;math&gt; c \geq 2&lt;/math&gt;.
   multiply(&lt;math&gt;y,z&lt;/math&gt;)
   #Return the product &lt;math&gt;yz&lt;/math&gt;.
       ''if'' &lt;math&gt;z=0&lt;/math&gt; ''then'' return(0) ''else''
        return(multiply(&lt;math&gt;cy,\lfloor z/c \rfloor)+y \cdot (z\,\bmod\,c&lt;/math&gt;))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial. P(x) = &lt;math&gt;a_nx^n + a_{n-1}x^{n-1} + \dots + a_1x + a_0&lt;/math&gt;
    horner(&lt;math&gt;A,x&lt;/math&gt;)
       &lt;math&gt;p = A_n&lt;/math&gt;
       for &lt;math&gt;i&lt;/math&gt; from &lt;math&gt;n-1&lt;/math&gt; to &lt;math&gt;0&lt;/math&gt;
               &lt;math&gt;p = p*x+A_i&lt;/math&gt;
       return &lt;math&gt;p&lt;/math&gt;
[[1.9|Solution]]


:1.10. Prove the correctness of the following sorting algorithm.
    bubblesort (&lt;math&gt;A&lt;/math&gt; : list[&lt;math&gt;1 \dots n&lt;/math&gt;])
       for &lt;math&gt;i&lt;/math&gt; from &lt;math&gt;n&lt;/math&gt; to &lt;math&gt;1&lt;/math&gt;
           for &lt;math&gt;j&lt;/math&gt; from &lt;math&gt;1&lt;/math&gt; to &lt;math&gt;i-1&lt;/math&gt;
               if (&lt;math&gt;A[j] &gt; A[j+1]&lt;/math&gt;)
                   swap the values of &lt;math&gt;A[j]&lt;/math&gt; and &lt;math&gt;A[j+1]&lt;/math&gt;


:[[1.11]]. The ''greatest common divisor of positive'' integers &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt; is the largest integer &lt;math&gt;d&lt;/math&gt; such that &lt;math&gt;d&lt;/math&gt; divides &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;d&lt;/math&gt; divides &lt;math&gt;y&lt;/math&gt;. Euclid’s algorithm to compute &lt;math&gt;gcd(x, y)&lt;/math&gt; where &lt;math&gt;x &gt; y&lt;/math&gt; reduces the task to a smaller problem:

:::::&lt;math&gt;gcd(x, y) = gcd(y, x mod y)&lt;/math&gt;

:Prove that Euclid’s algorithm is correct.
[[1.11|Solution]]


===Induction===

:1.12. Prove that &lt;math&gt;\sum_{i=1}^n i&lt;/math&gt;=&lt;math&gt;n(n+1)/2&lt;/math&gt; for &lt;math&gt;n \geq 0&lt;/math&gt;, by induction.


:[[1.13]]. Prove that &lt;math&gt;\sum_{i=1}^n i^2&lt;/math&gt;=&lt;math&gt;n(n+1)(2n+1)/6&lt;/math&gt; for &lt;math&gt;n \geq\ 0&lt;/math&gt;, by induction.
[[1.13|Solution]]


:1.14. Prove that &lt;math&gt;\sum_{i=1}^n i^3&lt;/math&gt;=&lt;math&gt;n^2(n+1)^2/4&lt;/math&gt; for &lt;math&gt;n \geq 0&lt;/math&gt;, by induction.


:[[1.15]]. Prove that &lt;math&gt; \sum_{i=1}^n i(i+1)(i+2)=n(n+1)(n+2)(n+3)/4 &lt;/math&gt;
[[1.15|Solution]]


:1.16. Prove by induction on &lt;math&gt;n \geq 1&lt;/math&gt; that for every &lt;math&gt;a \neq 1&lt;/math&gt;, &lt;math&gt; \sum_{i=0}^n a^i =\frac{a^{n+1}-1}{a-1}&lt;/math&gt;


:[[1.17]]. Prove by induction that for &lt;math&gt;n \geq 1&lt;/math&gt;, &lt;math&gt; \sum_{i=1}^n \frac{1}{i(i+1)} = \frac{n}{n+1} &lt;/math&gt;
[[1.17|Solution]]


:1.18. Prove by induction that &lt;math&gt;n^3+2n&lt;/math&gt; is divisible by &lt;math&gt;3&lt;/math&gt; for all &lt;math&gt;n \geq 0&lt;/math&gt;.


:[[1.19]]. Prove by induction that a tree with &lt;math&gt;n&lt;/math&gt; vertices has exactly &lt;math&gt;n-1&lt;/math&gt; edges.
[[1.19|Solution]]


:1.20. Prove by mathematical induction that the sum of the cubes of the first &lt;math&gt;n&lt;/math&gt; positive integers is equal to the square of the sum of these integers, i.e.

::::::::::::&lt;math&gt; \sum_{i=1}^n i^3 = (  \sum_{i=1}^n i )^2 &lt;/math&gt;


===Estimation===

:[[1.21]]. Do all the books you own total at least one million pages? How many total pages are stored in your school library?
[[1.21|Solution]]


:1.22. How many words are there in this textbook?


:[[1.23]]. How many hours are one million seconds? How many days? Answer these questions by doing all arithmetic in your head.
[[1.23|Solution]]


:1.24. Estimate how many cities and towns there are in the United States.


:[[1.25]]. Estimate how many cubic miles of water flow out of the mouth of the Mississippi River each day. Do not look up any supplemental facts. Describe all assumptions you made in arriving at your answer.
[[1.25|Solution]]


:1.26. How many Starbucks or McDonald’s locations are there in your country?


:[[1.27]]. How long would it take to empty a bathtub with a drinking straw?
[[1.27|Solution]]


:1.28. Is disk drive access time normally measured in milliseconds (thousandths of a second) or microseconds (millionths of a second)? Does your RAM memory access a word in more or less than a microsecond? How many instructions can your CPU execute in one year if the machine is left running all the time?


:[[1.29]]. A sorting algorithm takes 1 second to sort 1,000 items on your machine. How long will it take to sort 10,000 items. . .
::(a) if you believe that the algorithm takes time proportional to n2, and
::(b) if you believe that the algorithm takes time roughly proportional to n log n?
[[1.29|Solution]]


===Implementation Projects===

:1.30. Implement the two TSP heuristics of Section 1.1 (page 5). Which of them gives better solutions in practice? Can you devise a heuristic that works better than both of them?


:[[1.31]]. Describe how to test whether a given set of tickets establishes sufficient coverage in the Lotto problem of Section 1.8 (page 22). Write a program to find good ticket sets.
[[1.31|Solution]]


===Interview Problems===

:1.32. Write a function to perform integer division without using either the / or * operators. Find a fast way to do it.


:[[1.33]]. There are twenty-five horses. At most, five horses can race together at a time. You must determine the fastest, second fastest, and third fastest horses. Find the minimum number of races in which this can be done.
[[1.33|Solution]]


:1.34. How many piano tuners are there in the entire world?


:[[1.35]]. How many gas stations are there in the United States?
[[1.35|Solution]]


:1.36. How much does the ice in a hockey rink weigh?


:[[1.37]]. How many miles of road are there in the United States?
[[1.37|Solution]]


:1.38. On average, how many times would you have to flip open the Manhattan phone book at random in order to find a specific name?


Back to [[Chapter List]]</text>
      <sha1>axmh2hf5co3lsn8g5xrfedgjbmzgcat</sha1>
    </revision>
    <revision>
      <id>446</id>
      <parentid>162</parentid>
      <timestamp>2020-10-01T18:05:51Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <minor/>
      <comment>Protected "[[Chapter 1]]" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="8733">Below are the exercises at the end of chapter 1 of the third edition of the Algorithm Design Manual by Steven Skiena. Student proposed answers to odd number questions are available by clicking on the question number.

=Introduction to Algorithms=

===Finding Counter Examples===

:[[1.1]]. Show that &lt;math&gt;a + b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.
[[1.1|Solution]]


:1.2. Show that &lt;math&gt;a \times b&lt;/math&gt; can be less than &lt;math&gt;\min(a,b)&lt;/math&gt;.


:[[1.3]]. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the fastest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the shortest route.
[[1.3|Solution]]


:1.4. Design/draw a road network with two points &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; such that the shortest route between &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; is not the route with the fewest turns.


:[[1.5]]. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = \{s_1, s_2, \ldots, s_n\}&lt;/math&gt;, and a target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; which adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, there exists a subset within &lt;math&gt;S = \{1, 2, 5, 9, 10\}&lt;/math&gt; that adds up to &lt;math&gt;T=22&lt;/math&gt; but not &lt;math&gt;T=23&lt;/math&gt;.
:Find counterexamples to each of the following algorithms for the knapsack problem. That is, giving an &lt;math&gt;S&lt;/math&gt; and &lt;math&gt;T&lt;/math&gt; such that the subset is selected using the algorithm does not leave the knapsack completely full, even though such a solution exists.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack in left to right order if they fit, i.e. the first-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from smallest to largest, i.e. the best-fit algorithm.
#Put the elements of &lt;math&gt;S&lt;/math&gt; in the knapsack from largest to smallest.
[[1.5|Solution]]


:1.6. The ''set cover problem'' is as follows: given a set &lt;math&gt;S&lt;/math&gt; of subsets &lt;math&gt; S_1, ..., S_m&lt;/math&gt; of the universal set &lt;math&gt;U = \{1,...,n\}&lt;/math&gt;, find the smallest subset of subsets &lt;math&gt;T \subset S&lt;/math&gt; such that &lt;math&gt;\cup_{t_i \in T} t_i = U&lt;/math&gt;.For example, there are the following subsets, &lt;math&gt;S_1 = \{1, 3, 5\}&lt;/math&gt;, &lt;math&gt;S_2 = \{2,4\}&lt;/math&gt;, &lt;math&gt;S_3 = \{1,4\}&lt;/math&gt;, and &lt;math&gt;S_4 = \{2,5\}&lt;/math&gt; The set cover would then be &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt;.

:Find a counterexample for the following algorithm: Select the largest subset for the cover, and then delete all its elements from the universal set. Repeat by adding the subset containing the largest number of uncovered elements until all are covered.


:[[1.7]]. The ''maximum clique problem'' in a graph &lt;math&gt;G = (V, E)&lt;/math&gt; asks for the largest subset &lt;math&gt;C&lt;/math&gt; of vertices &lt;math&gt;V&lt;/math&gt; such that there is an edge in &lt;math&gt;E&lt;/math&gt; between every pair of vertices in &lt;math&gt;C&lt;/math&gt;. Find a counterexample for the following algorithm: Sort the vertices of &lt;math&gt;G&lt;/math&gt; from highest to lowest degree. Considering the vertices in order of degree, for each vertex add it to the clique if it is a neighbor of all vertices currently in the clique. Repeat until all vertices have been considered.
[[1.7|Solution]]


===Proofs of Correctness===

:1.8. Prove the correctness of the following recursive algorithm to multiply two natural numbers, for all integer constants &lt;math&gt; c \geq 2&lt;/math&gt;.
   multiply(&lt;math&gt;y,z&lt;/math&gt;)
   #Return the product &lt;math&gt;yz&lt;/math&gt;.
       ''if'' &lt;math&gt;z=0&lt;/math&gt; ''then'' return(0) ''else''
        return(multiply(&lt;math&gt;cy,\lfloor z/c \rfloor)+y \cdot (z\,\bmod\,c&lt;/math&gt;))


:[[1.9]]. Prove the correctness of the following algorithm for evaluating a polynomial. P(x) = &lt;math&gt;a_nx^n + a_{n-1}x^{n-1} + \dots + a_1x + a_0&lt;/math&gt;
    horner(&lt;math&gt;A,x&lt;/math&gt;)
       &lt;math&gt;p = A_n&lt;/math&gt;
       for &lt;math&gt;i&lt;/math&gt; from &lt;math&gt;n-1&lt;/math&gt; to &lt;math&gt;0&lt;/math&gt;
               &lt;math&gt;p = p*x+A_i&lt;/math&gt;
       return &lt;math&gt;p&lt;/math&gt;
[[1.9|Solution]]


:1.10. Prove the correctness of the following sorting algorithm.
    bubblesort (&lt;math&gt;A&lt;/math&gt; : list[&lt;math&gt;1 \dots n&lt;/math&gt;])
       for &lt;math&gt;i&lt;/math&gt; from &lt;math&gt;n&lt;/math&gt; to &lt;math&gt;1&lt;/math&gt;
           for &lt;math&gt;j&lt;/math&gt; from &lt;math&gt;1&lt;/math&gt; to &lt;math&gt;i-1&lt;/math&gt;
               if (&lt;math&gt;A[j] &gt; A[j+1]&lt;/math&gt;)
                   swap the values of &lt;math&gt;A[j]&lt;/math&gt; and &lt;math&gt;A[j+1]&lt;/math&gt;


:[[1.11]]. The ''greatest common divisor of positive'' integers &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt; is the largest integer &lt;math&gt;d&lt;/math&gt; such that &lt;math&gt;d&lt;/math&gt; divides &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;d&lt;/math&gt; divides &lt;math&gt;y&lt;/math&gt;. Euclid’s algorithm to compute &lt;math&gt;gcd(x, y)&lt;/math&gt; where &lt;math&gt;x &gt; y&lt;/math&gt; reduces the task to a smaller problem:

:::::&lt;math&gt;gcd(x, y) = gcd(y, x mod y)&lt;/math&gt;

:Prove that Euclid’s algorithm is correct.
[[1.11|Solution]]


===Induction===

:1.12. Prove that &lt;math&gt;\sum_{i=1}^n i&lt;/math&gt;=&lt;math&gt;n(n+1)/2&lt;/math&gt; for &lt;math&gt;n \geq 0&lt;/math&gt;, by induction.


:[[1.13]]. Prove that &lt;math&gt;\sum_{i=1}^n i^2&lt;/math&gt;=&lt;math&gt;n(n+1)(2n+1)/6&lt;/math&gt; for &lt;math&gt;n \geq\ 0&lt;/math&gt;, by induction.
[[1.13|Solution]]


:1.14. Prove that &lt;math&gt;\sum_{i=1}^n i^3&lt;/math&gt;=&lt;math&gt;n^2(n+1)^2/4&lt;/math&gt; for &lt;math&gt;n \geq 0&lt;/math&gt;, by induction.


:[[1.15]]. Prove that &lt;math&gt; \sum_{i=1}^n i(i+1)(i+2)=n(n+1)(n+2)(n+3)/4 &lt;/math&gt;
[[1.15|Solution]]


:1.16. Prove by induction on &lt;math&gt;n \geq 1&lt;/math&gt; that for every &lt;math&gt;a \neq 1&lt;/math&gt;, &lt;math&gt; \sum_{i=0}^n a^i =\frac{a^{n+1}-1}{a-1}&lt;/math&gt;


:[[1.17]]. Prove by induction that for &lt;math&gt;n \geq 1&lt;/math&gt;, &lt;math&gt; \sum_{i=1}^n \frac{1}{i(i+1)} = \frac{n}{n+1} &lt;/math&gt;
[[1.17|Solution]]


:1.18. Prove by induction that &lt;math&gt;n^3+2n&lt;/math&gt; is divisible by &lt;math&gt;3&lt;/math&gt; for all &lt;math&gt;n \geq 0&lt;/math&gt;.


:[[1.19]]. Prove by induction that a tree with &lt;math&gt;n&lt;/math&gt; vertices has exactly &lt;math&gt;n-1&lt;/math&gt; edges.
[[1.19|Solution]]


:1.20. Prove by mathematical induction that the sum of the cubes of the first &lt;math&gt;n&lt;/math&gt; positive integers is equal to the square of the sum of these integers, i.e.

::::::::::::&lt;math&gt; \sum_{i=1}^n i^3 = (  \sum_{i=1}^n i )^2 &lt;/math&gt;


===Estimation===

:[[1.21]]. Do all the books you own total at least one million pages? How many total pages are stored in your school library?
[[1.21|Solution]]


:1.22. How many words are there in this textbook?


:[[1.23]]. How many hours are one million seconds? How many days? Answer these questions by doing all arithmetic in your head.
[[1.23|Solution]]


:1.24. Estimate how many cities and towns there are in the United States.


:[[1.25]]. Estimate how many cubic miles of water flow out of the mouth of the Mississippi River each day. Do not look up any supplemental facts. Describe all assumptions you made in arriving at your answer.
[[1.25|Solution]]


:1.26. How many Starbucks or McDonald’s locations are there in your country?


:[[1.27]]. How long would it take to empty a bathtub with a drinking straw?
[[1.27|Solution]]


:1.28. Is disk drive access time normally measured in milliseconds (thousandths of a second) or microseconds (millionths of a second)? Does your RAM memory access a word in more or less than a microsecond? How many instructions can your CPU execute in one year if the machine is left running all the time?


:[[1.29]]. A sorting algorithm takes 1 second to sort 1,000 items on your machine. How long will it take to sort 10,000 items. . .
::(a) if you believe that the algorithm takes time proportional to n2, and
::(b) if you believe that the algorithm takes time roughly proportional to n log n?
[[1.29|Solution]]


===Implementation Projects===

:1.30. Implement the two TSP heuristics of Section 1.1 (page 5). Which of them gives better solutions in practice? Can you devise a heuristic that works better than both of them?


:[[1.31]]. Describe how to test whether a given set of tickets establishes sufficient coverage in the Lotto problem of Section 1.8 (page 22). Write a program to find good ticket sets.
[[1.31|Solution]]


===Interview Problems===

:1.32. Write a function to perform integer division without using either the / or * operators. Find a fast way to do it.


:[[1.33]]. There are twenty-five horses. At most, five horses can race together at a time. You must determine the fastest, second fastest, and third fastest horses. Find the minimum number of races in which this can be done.
[[1.33|Solution]]


:1.34. How many piano tuners are there in the entire world?


:[[1.35]]. How many gas stations are there in the United States?
[[1.35|Solution]]


:1.36. How much does the ice in a hockey rink weigh?


:[[1.37]]. How many miles of road are there in the United States?
[[1.37|Solution]]


:1.38. On average, how many times would you have to flip open the Manhattan phone book at random in order to find a specific name?


Back to [[Chapter List]]</text>
      <sha1>axmh2hf5co3lsn8g5xrfedgjbmzgcat</sha1>
    </revision>
  </page>
  <page>
    <title>Chapter 10</title>
    <ns>0</ns>
    <id>13</id>
    <revision>
      <id>22</id>
      <timestamp>2020-08-23T19:35:47Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Problems   Back to [[Chapter List]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="35">Problems


Back to [[Chapter List]]</text>
      <sha1>95722ndl4ewzic1ak6z8g4auy0tqhc6</sha1>
    </revision>
    <revision>
      <id>120</id>
      <parentid>22</parentid>
      <timestamp>2020-09-07T19:33:14Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="665">=Dynamic Programming=

===Elementary Recurrences===

:[[10.1]]


:10.2


:[[10.3]]


:10.4


:[[10.5]]


===Edit Distance===

:10.6


:[[10.7]]


:10.8


:[[10.9]]


:10.10


===Greedy Algorithms===

:[[10.11]]


:10.12


:[[10.13]]


:10.14


===Number Problems===

:[[10.15]]


:10.16


:[[10.17]]


:10.18


:[[10.19]]


:10.20


:[[10.21]]


:10.22


:[[10.23]]


:10.24


:[[10.25]]


:10.26


===Graphing Problem===

:[[10.27]]


:10.28


:[[10.29]]


===Design Problems===

:10.30


:[[10.31]]


:10.32


:[[10.33]]


:10.34


:[[10.35]]


:10.36


:[[10.37]]


:10.38


===Interview Problems===

:[[10.39]]


:10.40


:[[10.41]]


Back to [[Chapter List]]</text>
      <sha1>1abtyn6dgb3gyrpuulorb46bbcbllah</sha1>
    </revision>
    <revision>
      <id>206</id>
      <parentid>120</parentid>
      <timestamp>2020-09-11T22:17:24Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Elementary Recurrences */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="2611">=Dynamic Programming=

===Elementary Recurrences===

:[[10.1]]. Up to &lt;math&gt;k&lt;/math&gt; steps in a single bound! A child is running up a staircase with &lt;math&gt;n&lt;/math&gt; steps and can hop between 1 and &lt;math&gt;k&lt;/math&gt; steps at a time. Design an algorithm to count how many possible ways the child can run up the stairs, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. What is the running time of your algorithm?
[[10.1|Solution]]


:10.2. Imagine you are a professional thief who plans to rob houses along a street of &lt;math&gt;n&lt;/math&gt; homes. You know the loot at house &lt;math&gt;i&lt;/math&gt; is worth &lt;math&gt;m_i&lt;/math&gt;, for &lt;math&gt;1 ≤ i ≤ n&lt;/math&gt;, but you cannot rob neighboring houses because their connected security systems will automatically contact the police if two adjacent houses are broken into. Give an efficient algorithm to determine the maximum amount of money you can steal without alerting the police.


:[[10.3]]. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible mixes (1s,2s,3s) of scoring add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are four possible solutions: (5, 0, 0), (2, 0, 1), (1, 2, 0), and (0, 1, 1).
[[10.3|Solution]]


:10.4. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible scoring sequences add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are thirteen possible sequences, including 1-2-1-1, 3-2, and 1-1-1-1-1.


:[[10.5]]. Given an &lt;math&gt;s × t&lt;/math&gt; grid filled with non-negative numbers, find a path from top left to bottom right that minimizes the sum of all numbers along its path. You can only move either down or right at any point in time.
::(a) Give a solution based on Dijkstra’s algorithm. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
(b) Give a solution based on dynamic programming. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?

===Edit Distance===

:10.6


:[[10.7]]


:10.8


:[[10.9]]


:10.10


===Greedy Algorithms===

:[[10.11]]


:10.12


:[[10.13]]


:10.14


===Number Problems===

:[[10.15]]


:10.16


:[[10.17]]


:10.18


:[[10.19]]


:10.20


:[[10.21]]


:10.22


:[[10.23]]


:10.24


:[[10.25]]


:10.26


===Graphing Problem===

:[[10.27]]


:10.28


:[[10.29]]


===Design Problems===

:10.30


:[[10.31]]


:10.32


:[[10.33]]


:10.34


:[[10.35]]


:10.36


:[[10.37]]


:10.38


===Interview Problems===

:[[10.39]]


:10.40


:[[10.41]]


Back to [[Chapter List]]</text>
      <sha1>hqwyv7qluc7u8ww80zgoxf30qltmw2u</sha1>
    </revision>
    <revision>
      <id>207</id>
      <parentid>206</parentid>
      <timestamp>2020-09-11T22:21:26Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Dynamic Programming */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="2613">=Dynamic Programming=

===Elementary Recurrences===

:[[10.1]]. Up to &lt;math&gt;k&lt;/math&gt; steps in a single bound! A child is running up a staircase with &lt;math&gt;n&lt;/math&gt; steps and can hop between 1 and &lt;math&gt;k&lt;/math&gt; steps at a time. Design an algorithm to count how many possible ways the child can run up the stairs, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. What is the running time of your algorithm?
[[10.1|Solution]]


:10.2. Imagine you are a professional thief who plans to rob houses along a street of &lt;math&gt;n&lt;/math&gt; homes. You know the loot at house &lt;math&gt;i&lt;/math&gt; is worth &lt;math&gt;m_i&lt;/math&gt;, for &lt;math&gt;1 ≤ i ≤ n&lt;/math&gt;, but you cannot rob neighboring houses because their connected security systems will automatically contact the police if two adjacent houses are broken into. Give an efficient algorithm to determine the maximum amount of money you can steal without alerting the police.


:[[10.3]]. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible mixes (1s,2s,3s) of scoring add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are four possible solutions: (5, 0, 0), (2, 0, 1), (1, 2, 0), and (0, 1, 1).
[[10.3|Solution]]


:10.4. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible scoring sequences add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are thirteen possible sequences, including 1-2-1-1, 3-2, and 1-1-1-1-1.


:[[10.5]]. Given an &lt;math&gt;s × t&lt;/math&gt; grid filled with non-negative numbers, find a path from top left to bottom right that minimizes the sum of all numbers along its path. You can only move either down or right at any point in time.
::(a) Give a solution based on Dijkstra’s algorithm. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
::(b) Give a solution based on dynamic programming. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?

===Edit Distance===

:10.6


:[[10.7]]


:10.8


:[[10.9]]


:10.10


===Greedy Algorithms===

:[[10.11]]


:10.12


:[[10.13]]


:10.14


===Number Problems===

:[[10.15]]


:10.16


:[[10.17]]


:10.18


:[[10.19]]


:10.20


:[[10.21]]


:10.22


:[[10.23]]


:10.24


:[[10.25]]


:10.26


===Graphing Problem===

:[[10.27]]


:10.28


:[[10.29]]


===Design Problems===

:10.30


:[[10.31]]


:10.32


:[[10.33]]


:10.34


:[[10.35]]


:10.36


:[[10.37]]


:10.38


===Interview Problems===

:[[10.39]]


:10.40


:[[10.41]]


Back to [[Chapter List]]</text>
      <sha1>jzl38cn936rvmzoql2zxmix56frpcs9</sha1>
    </revision>
    <revision>
      <id>208</id>
      <parentid>207</parentid>
      <timestamp>2020-09-11T22:22:58Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Elementary Recurrences */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="2613">=Dynamic Programming=

===Elementary Recurrences===

:[[10.1]]. Up to &lt;math&gt;k&lt;/math&gt; steps in a single bound! A child is running up a staircase with &lt;math&gt;n&lt;/math&gt; steps and can hop between 1 and &lt;math&gt;k&lt;/math&gt; steps at a time. Design an algorithm to count how many possible ways the child can run up the stairs, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. What is the running time of your algorithm?
[[10.1|Solution]]


:10.2. Imagine you are a professional thief who plans to rob houses along a street of &lt;math&gt;n&lt;/math&gt; homes. You know the loot at house &lt;math&gt;i&lt;/math&gt; is worth &lt;math&gt;m_i&lt;/math&gt;, for &lt;math&gt;1 \le i \le n&lt;/math&gt;, but you cannot rob neighboring houses because their connected security systems will automatically contact the police if two adjacent houses are broken into. Give an efficient algorithm to determine the maximum amount of money you can steal without alerting the police.


:[[10.3]]. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible mixes (1s,2s,3s) of scoring add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are four possible solutions: (5, 0, 0), (2, 0, 1), (1, 2, 0), and (0, 1, 1).
[[10.3|Solution]]


:10.4. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible scoring sequences add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are thirteen possible sequences, including 1-2-1-1, 3-2, and 1-1-1-1-1.


:[[10.5]]. Given an &lt;math&gt;s × t&lt;/math&gt; grid filled with non-negative numbers, find a path from top left to bottom right that minimizes the sum of all numbers along its path. You can only move either down or right at any point in time.
::(a) Give a solution based on Dijkstra’s algorithm. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
::(b) Give a solution based on dynamic programming. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?

===Edit Distance===

:10.6


:[[10.7]]


:10.8


:[[10.9]]


:10.10


===Greedy Algorithms===

:[[10.11]]


:10.12


:[[10.13]]


:10.14


===Number Problems===

:[[10.15]]


:10.16


:[[10.17]]


:10.18


:[[10.19]]


:10.20


:[[10.21]]


:10.22


:[[10.23]]


:10.24


:[[10.25]]


:10.26


===Graphing Problem===

:[[10.27]]


:10.28


:[[10.29]]


===Design Problems===

:10.30


:[[10.31]]


:10.32


:[[10.33]]


:10.34


:[[10.35]]


:10.36


:[[10.37]]


:10.38


===Interview Problems===

:[[10.39]]


:10.40


:[[10.41]]


Back to [[Chapter List]]</text>
      <sha1>bbb3pgoqulcg6x9nia50jpv6569i0td</sha1>
    </revision>
    <revision>
      <id>209</id>
      <parentid>208</parentid>
      <timestamp>2020-09-11T22:23:21Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Elementary Recurrences */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="2612">=Dynamic Programming=

===Elementary Recurrences===

:[[10.1]]. Up to &lt;math&gt;k&lt;/math&gt; steps in a single bound! A child is running up a staircase with &lt;math&gt;n&lt;/math&gt; steps and can hop between 1 and &lt;math&gt;k&lt;/math&gt; steps at a time. Design an algorithm to count how many possible ways the child can run up the stairs, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. What is the running time of your algorithm?
[[10.1|Solution]]


:10.2. Imagine you are a professional thief who plans to rob houses along a street of &lt;math&gt;n&lt;/math&gt; homes. You know the loot at house &lt;math&gt;i&lt;/math&gt; is worth &lt;math&gt;m_i&lt;/math&gt;, for &lt;math&gt;1 \le i \le n&lt;/math&gt;, but you cannot rob neighboring houses because their connected security systems will automatically contact the police if two adjacent houses are broken into. Give an efficient algorithm to determine the maximum amount of money you can steal without alerting the police.


:[[10.3]]. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible mixes (1s,2s,3s) of scoring add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are four possible solutions: (5, 0, 0), (2, 0, 1), (1, 2, 0), and (0, 1, 1).
[[10.3|Solution]]


:10.4. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible scoring sequences add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are thirteen possible sequences, including 1-2-1-1, 3-2, and 1-1-1-1-1.


:[[10.5]]. Given an &lt;math&gt;s * t&lt;/math&gt; grid filled with non-negative numbers, find a path from top left to bottom right that minimizes the sum of all numbers along its path. You can only move either down or right at any point in time.
::(a) Give a solution based on Dijkstra’s algorithm. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
::(b) Give a solution based on dynamic programming. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?

===Edit Distance===

:10.6


:[[10.7]]


:10.8


:[[10.9]]


:10.10


===Greedy Algorithms===

:[[10.11]]


:10.12


:[[10.13]]


:10.14


===Number Problems===

:[[10.15]]


:10.16


:[[10.17]]


:10.18


:[[10.19]]


:10.20


:[[10.21]]


:10.22


:[[10.23]]


:10.24


:[[10.25]]


:10.26


===Graphing Problem===

:[[10.27]]


:10.28


:[[10.29]]


===Design Problems===

:10.30


:[[10.31]]


:10.32


:[[10.33]]


:10.34


:[[10.35]]


:10.36


:[[10.37]]


:10.38


===Interview Problems===

:[[10.39]]


:10.40


:[[10.41]]


Back to [[Chapter List]]</text>
      <sha1>bxlp6jaoju56f8qyhehsny70jtiakwo</sha1>
    </revision>
    <revision>
      <id>210</id>
      <parentid>209</parentid>
      <timestamp>2020-09-13T00:07:48Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Elementary Recurrences */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="2630">=Dynamic Programming=

===Elementary Recurrences===

:[[10.1]]. Up to &lt;math&gt;k&lt;/math&gt; steps in a single bound! A child is running up a staircase with &lt;math&gt;n&lt;/math&gt; steps and can hop between 1 and &lt;math&gt;k&lt;/math&gt; steps at a time. Design an algorithm to count how many possible ways the child can run up the stairs, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. What is the running time of your algorithm?
[[10.1|Solution]]


:10.2. Imagine you are a professional thief who plans to rob houses along a street of &lt;math&gt;n&lt;/math&gt; homes. You know the loot at house &lt;math&gt;i&lt;/math&gt; is worth &lt;math&gt;m_i&lt;/math&gt;, for &lt;math&gt;1 \le i \le n&lt;/math&gt;, but you cannot rob neighboring houses because their connected security systems will automatically contact the police if two adjacent houses are broken into. Give an efficient algorithm to determine the maximum amount of money you can steal without alerting the police.


:[[10.3]]. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible mixes (1s,2s,3s) of scoring add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are four possible solutions: (5, 0, 0), (2, 0, 1), (1, 2, 0), and (0, 1, 1).
[[10.3|Solution]]


:10.4. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible scoring sequences add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are thirteen possible sequences, including 1-2-1-1, 3-2, and 1-1-1-1-1.


:[[10.5]]. Given an &lt;math&gt;s * t&lt;/math&gt; grid filled with non-negative numbers, find a path from top left to bottom right that minimizes the sum of all numbers along its path. You can only move either down or right at any point in time.
::(a) Give a solution based on Dijkstra’s algorithm. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
::(b) Give a solution based on dynamic programming. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
[[10.5|Solution]]

===Edit Distance===

:10.6


:[[10.7]]


:10.8


:[[10.9]]


:10.10


===Greedy Algorithms===

:[[10.11]]


:10.12


:[[10.13]]


:10.14


===Number Problems===

:[[10.15]]


:10.16


:[[10.17]]


:10.18


:[[10.19]]


:10.20


:[[10.21]]


:10.22


:[[10.23]]


:10.24


:[[10.25]]


:10.26


===Graphing Problem===

:[[10.27]]


:10.28


:[[10.29]]


===Design Problems===

:10.30


:[[10.31]]


:10.32


:[[10.33]]


:10.34


:[[10.35]]


:10.36


:[[10.37]]


:10.38


===Interview Problems===

:[[10.39]]


:10.40


:[[10.41]]


Back to [[Chapter List]]</text>
      <sha1>hvvr7w9vqk4rmpu93seji3alofe5gu8</sha1>
    </revision>
    <revision>
      <id>211</id>
      <parentid>210</parentid>
      <timestamp>2020-09-13T19:25:20Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Edit Distance */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="5860">=Dynamic Programming=

===Elementary Recurrences===

:[[10.1]]. Up to &lt;math&gt;k&lt;/math&gt; steps in a single bound! A child is running up a staircase with &lt;math&gt;n&lt;/math&gt; steps and can hop between 1 and &lt;math&gt;k&lt;/math&gt; steps at a time. Design an algorithm to count how many possible ways the child can run up the stairs, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. What is the running time of your algorithm?
[[10.1|Solution]]


:10.2. Imagine you are a professional thief who plans to rob houses along a street of &lt;math&gt;n&lt;/math&gt; homes. You know the loot at house &lt;math&gt;i&lt;/math&gt; is worth &lt;math&gt;m_i&lt;/math&gt;, for &lt;math&gt;1 \le i \le n&lt;/math&gt;, but you cannot rob neighboring houses because their connected security systems will automatically contact the police if two adjacent houses are broken into. Give an efficient algorithm to determine the maximum amount of money you can steal without alerting the police.


:[[10.3]]. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible mixes (1s,2s,3s) of scoring add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are four possible solutions: (5, 0, 0), (2, 0, 1), (1, 2, 0), and (0, 1, 1).
[[10.3|Solution]]


:10.4. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible scoring sequences add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are thirteen possible sequences, including 1-2-1-1, 3-2, and 1-1-1-1-1.


:[[10.5]]. Given an &lt;math&gt;s * t&lt;/math&gt; grid filled with non-negative numbers, find a path from top left to bottom right that minimizes the sum of all numbers along its path. You can only move either down or right at any point in time.
::(a) Give a solution based on Dijkstra’s algorithm. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
::(b) Give a solution based on dynamic programming. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
[[10.5|Solution]]

===Edit Distance===

:10.6. Typists often make transposition errors exchanging neighboring characters,
such as typing “setve” for “steve.” This requires two substitutions to fix under
the conventional definition of edit distance.
:Incorporate a swap operation into our edit distance function, so that such neigh-
boring transposition errors can be fixed at the cost of one operation.


:[[10.7]]. Suppose you are given three strings of characters: &lt;math&gt;X&lt;/math&gt;, &lt;math&gt;Y&lt;/math&gt;, and &lt;math&gt;Z&lt;/math&gt;, where &lt;math&gt;|X| = n&lt;/math&gt;, &lt;math&gt;|Y| = m&lt;/math&gt;, and &lt;math&gt;|Z| = n + m&lt;/math&gt;. &lt;math&gt;Z&lt;/math&gt; is said to be a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; iff &lt;math&gt;Z&lt;/math&gt; can be formed by interleaving the characters from &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; in a way that maintains the left-to-right ordering of the characters from each string. 
:(a) Show that cchocohilaptes is a shuffle of chocolate and chips, but chocochilatspe is not.
:(b) Give an efficient dynamic programming algorithm that determines whether &lt;math&gt;Z&lt;/math&gt; is a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt;. (Hint: the values of the dynamic programming matrix you construct should be Boolean, not numeric.)
[[10.7|Solution]]


:10.8. The longest common substring (not subsequence) of two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; is the longest string that appears as a run of consecutive letters in both strings. For example, the longest common substring of photograph and tomography is ograph.
:(a) Let &lt;math&gt;n = |X|&lt;/math&gt; and &lt;math&gt;m = |Y|&lt;/math&gt;. Give a &lt;math&gt;\Theta (nm)&lt;/math&gt; dynamic programming algorithm for longest common substring based on the longest common subsequence/edit distance algorithm.
(b) Give a simpler &lt;math&gt;\Theta (nm)&lt;/math&gt; algorithm that does not rely on dynamic programming.


:[[10.9]]. The ''longest common subsequence (LCS)'' of two sequences &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the longest sequence &lt;math&gt;L&lt;/math&gt; such that &lt;math&gt;L&lt;/math&gt; is a subsequence of both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;. The ''shortest common supersequence (SCS)'' of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the smallest sequence &lt;math&gt;L&lt;/math&gt; such that both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; are a subsequence of &lt;math&gt;L&lt;/math&gt;.
:(a) Give efficient algorithms to find the LCS and SCS of two given sequences.
:(b) Let &lt;math&gt;d(T, P)&lt;/math&gt; be the minimum edit distance between &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; when no substitutions are allowed (i.e., the only changes are character insertion and deletion). Prove that &lt;math&gt;d(T, P) = |SCS(T, P)| − |LCS(T, P)|&lt;/math&gt; where &lt;math&gt;|SCS(T, P)| (|LCS(T, P)|)&lt;/math&gt; is the size of the shortest SCS (longest LCS) of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;.
[[10.9||Solution]]


:10.10. Suppose you are given &lt;math&gt;n&lt;/math&gt; poker chips stacked in two stacks, where the edges of all chips can be seen. Each chip is one of three colors. A turn consists of choosing a color and removing all chips of that color from the tops of the stacks. The goal is to minimize the number of turns until the chips are gone. 
:For example, consider the stacks &lt;math&gt;(RRGG, GBBB)&lt;/math&gt;. Playing red, green, and then blue suffices to clear the stacks in three moves. Give an &lt;math&gt;O(n^2)&lt;/math&gt; dynamic programming algorithm to find the best strategy for a given pair of chip piles.

===Greedy Algorithms===

:[[10.11]]


:10.12


:[[10.13]]


:10.14


===Number Problems===

:[[10.15]]


:10.16


:[[10.17]]


:10.18


:[[10.19]]


:10.20


:[[10.21]]


:10.22


:[[10.23]]


:10.24


:[[10.25]]


:10.26


===Graphing Problem===

:[[10.27]]


:10.28


:[[10.29]]


===Design Problems===

:10.30


:[[10.31]]


:10.32


:[[10.33]]


:10.34


:[[10.35]]


:10.36


:[[10.37]]


:10.38


===Interview Problems===

:[[10.39]]


:10.40


:[[10.41]]


Back to [[Chapter List]]</text>
      <sha1>f47ewp2pvhcd28qu2df3he2qzjbandv</sha1>
    </revision>
    <revision>
      <id>212</id>
      <parentid>211</parentid>
      <timestamp>2020-09-13T19:28:05Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Edit Distance */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="5858">=Dynamic Programming=

===Elementary Recurrences===

:[[10.1]]. Up to &lt;math&gt;k&lt;/math&gt; steps in a single bound! A child is running up a staircase with &lt;math&gt;n&lt;/math&gt; steps and can hop between 1 and &lt;math&gt;k&lt;/math&gt; steps at a time. Design an algorithm to count how many possible ways the child can run up the stairs, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. What is the running time of your algorithm?
[[10.1|Solution]]


:10.2. Imagine you are a professional thief who plans to rob houses along a street of &lt;math&gt;n&lt;/math&gt; homes. You know the loot at house &lt;math&gt;i&lt;/math&gt; is worth &lt;math&gt;m_i&lt;/math&gt;, for &lt;math&gt;1 \le i \le n&lt;/math&gt;, but you cannot rob neighboring houses because their connected security systems will automatically contact the police if two adjacent houses are broken into. Give an efficient algorithm to determine the maximum amount of money you can steal without alerting the police.


:[[10.3]]. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible mixes (1s,2s,3s) of scoring add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are four possible solutions: (5, 0, 0), (2, 0, 1), (1, 2, 0), and (0, 1, 1).
[[10.3|Solution]]


:10.4. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible scoring sequences add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are thirteen possible sequences, including 1-2-1-1, 3-2, and 1-1-1-1-1.


:[[10.5]]. Given an &lt;math&gt;s * t&lt;/math&gt; grid filled with non-negative numbers, find a path from top left to bottom right that minimizes the sum of all numbers along its path. You can only move either down or right at any point in time.
::(a) Give a solution based on Dijkstra’s algorithm. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
::(b) Give a solution based on dynamic programming. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
[[10.5|Solution]]

===Edit Distance===

:10.6. Typists often make transposition errors exchanging neighboring characters, such as typing “setve” for “steve.” This requires two substitutions to fix under the conventional definition of edit distance.
:Incorporate a swap operation into our edit distance function, so that such neigh-
boring transposition errors can be fixed at the cost of one operation.


:[[10.7]]. Suppose you are given three strings of characters: &lt;math&gt;X&lt;/math&gt;, &lt;math&gt;Y&lt;/math&gt;, and &lt;math&gt;Z&lt;/math&gt;, where &lt;math&gt;|X| = n&lt;/math&gt;, &lt;math&gt;|Y| = m&lt;/math&gt;, and &lt;math&gt;|Z| = n + m&lt;/math&gt;. &lt;math&gt;Z&lt;/math&gt; is said to be a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; iff &lt;math&gt;Z&lt;/math&gt; can be formed by interleaving the characters from &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; in a way that maintains the left-to-right ordering of the characters from each string. 
:(a) Show that cchocohilaptes is a shuffle of chocolate and chips, but chocochilatspe is not.
:(b) Give an efficient dynamic programming algorithm that determines whether &lt;math&gt;Z&lt;/math&gt; is a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt;. (Hint: the values of the dynamic programming matrix you construct should be Boolean, not numeric.)
[[10.7|Solution]]


:10.8. The longest common substring (not subsequence) of two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; is the longest string that appears as a run of consecutive letters in both strings. For example, the longest common substring of photograph and tomography is ograph.
:(a) Let &lt;math&gt;n = |X|&lt;/math&gt; and &lt;math&gt;m = |Y|&lt;/math&gt;. Give a &lt;math&gt;\Theta (nm)&lt;/math&gt; dynamic programming algorithm for longest common substring based on the longest common subsequence/edit distance algorithm.
:(b) Give a simpler &lt;math&gt;\Theta (nm)&lt;/math&gt; algorithm that does not rely on dynamic programming.


:[[10.9]]. The ''longest common subsequence (LCS)'' of two sequences &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the longest sequence &lt;math&gt;L&lt;/math&gt; such that &lt;math&gt;L&lt;/math&gt; is a subsequence of both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;. The ''shortest common supersequence (SCS)'' of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the smallest sequence &lt;math&gt;L&lt;/math&gt; such that both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; are a subsequence of &lt;math&gt;L&lt;/math&gt;.
:(a) Give efficient algorithms to find the LCS and SCS of two given sequences.
:(b) Let &lt;math&gt;d(T, P)&lt;/math&gt; be the minimum edit distance between &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; when no substitutions are allowed (i.e., the only changes are character insertion and deletion). Prove that &lt;math&gt;d(T, P) = |SCS(T, P)| - |LCS(T, P)|&lt;/math&gt; where &lt;math&gt;|SCS(T, P)| (|LCS(T, P)|)&lt;/math&gt; is the size of the shortest SCS (longest LCS) of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;.
[[10.9|Solution]]


:10.10. Suppose you are given &lt;math&gt;n&lt;/math&gt; poker chips stacked in two stacks, where the edges of all chips can be seen. Each chip is one of three colors. A turn consists of choosing a color and removing all chips of that color from the tops of the stacks. The goal is to minimize the number of turns until the chips are gone. 
:For example, consider the stacks &lt;math&gt;(RRGG, GBBB)&lt;/math&gt;. Playing red, green, and then blue suffices to clear the stacks in three moves. Give an &lt;math&gt;O(n^2)&lt;/math&gt; dynamic programming algorithm to find the best strategy for a given pair of chip piles.

===Greedy Algorithms===

:[[10.11]]


:10.12


:[[10.13]]


:10.14


===Number Problems===

:[[10.15]]


:10.16


:[[10.17]]


:10.18


:[[10.19]]


:10.20


:[[10.21]]


:10.22


:[[10.23]]


:10.24


:[[10.25]]


:10.26


===Graphing Problem===

:[[10.27]]


:10.28


:[[10.29]]


===Design Problems===

:10.30


:[[10.31]]


:10.32


:[[10.33]]


:10.34


:[[10.35]]


:10.36


:[[10.37]]


:10.38


===Interview Problems===

:[[10.39]]


:10.40


:[[10.41]]


Back to [[Chapter List]]</text>
      <sha1>lom7wzru6fknqgh6umankn7s99g4jyn</sha1>
    </revision>
    <revision>
      <id>213</id>
      <parentid>212</parentid>
      <timestamp>2020-09-13T19:44:07Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Number Problems */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="7989">=Dynamic Programming=

===Elementary Recurrences===

:[[10.1]]. Up to &lt;math&gt;k&lt;/math&gt; steps in a single bound! A child is running up a staircase with &lt;math&gt;n&lt;/math&gt; steps and can hop between 1 and &lt;math&gt;k&lt;/math&gt; steps at a time. Design an algorithm to count how many possible ways the child can run up the stairs, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. What is the running time of your algorithm?
[[10.1|Solution]]


:10.2. Imagine you are a professional thief who plans to rob houses along a street of &lt;math&gt;n&lt;/math&gt; homes. You know the loot at house &lt;math&gt;i&lt;/math&gt; is worth &lt;math&gt;m_i&lt;/math&gt;, for &lt;math&gt;1 \le i \le n&lt;/math&gt;, but you cannot rob neighboring houses because their connected security systems will automatically contact the police if two adjacent houses are broken into. Give an efficient algorithm to determine the maximum amount of money you can steal without alerting the police.


:[[10.3]]. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible mixes (1s,2s,3s) of scoring add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are four possible solutions: (5, 0, 0), (2, 0, 1), (1, 2, 0), and (0, 1, 1).
[[10.3|Solution]]


:10.4. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible scoring sequences add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are thirteen possible sequences, including 1-2-1-1, 3-2, and 1-1-1-1-1.


:[[10.5]]. Given an &lt;math&gt;s * t&lt;/math&gt; grid filled with non-negative numbers, find a path from top left to bottom right that minimizes the sum of all numbers along its path. You can only move either down or right at any point in time.
::(a) Give a solution based on Dijkstra’s algorithm. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
::(b) Give a solution based on dynamic programming. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
[[10.5|Solution]]

===Edit Distance===

:10.6. Typists often make transposition errors exchanging neighboring characters, such as typing “setve” for “steve.” This requires two substitutions to fix under the conventional definition of edit distance.
:Incorporate a swap operation into our edit distance function, so that such neigh-
boring transposition errors can be fixed at the cost of one operation.


:[[10.7]]. Suppose you are given three strings of characters: &lt;math&gt;X&lt;/math&gt;, &lt;math&gt;Y&lt;/math&gt;, and &lt;math&gt;Z&lt;/math&gt;, where &lt;math&gt;|X| = n&lt;/math&gt;, &lt;math&gt;|Y| = m&lt;/math&gt;, and &lt;math&gt;|Z| = n + m&lt;/math&gt;. &lt;math&gt;Z&lt;/math&gt; is said to be a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; iff &lt;math&gt;Z&lt;/math&gt; can be formed by interleaving the characters from &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; in a way that maintains the left-to-right ordering of the characters from each string. 
:(a) Show that cchocohilaptes is a shuffle of chocolate and chips, but chocochilatspe is not.
:(b) Give an efficient dynamic programming algorithm that determines whether &lt;math&gt;Z&lt;/math&gt; is a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt;. (Hint: the values of the dynamic programming matrix you construct should be Boolean, not numeric.)
[[10.7|Solution]]


:10.8. The longest common substring (not subsequence) of two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; is the longest string that appears as a run of consecutive letters in both strings. For example, the longest common substring of photograph and tomography is ograph.
:(a) Let &lt;math&gt;n = |X|&lt;/math&gt; and &lt;math&gt;m = |Y|&lt;/math&gt;. Give a &lt;math&gt;\Theta (nm)&lt;/math&gt; dynamic programming algorithm for longest common substring based on the longest common subsequence/edit distance algorithm.
:(b) Give a simpler &lt;math&gt;\Theta (nm)&lt;/math&gt; algorithm that does not rely on dynamic programming.


:[[10.9]]. The ''longest common subsequence (LCS)'' of two sequences &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the longest sequence &lt;math&gt;L&lt;/math&gt; such that &lt;math&gt;L&lt;/math&gt; is a subsequence of both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;. The ''shortest common supersequence (SCS)'' of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the smallest sequence &lt;math&gt;L&lt;/math&gt; such that both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; are a subsequence of &lt;math&gt;L&lt;/math&gt;.
:(a) Give efficient algorithms to find the LCS and SCS of two given sequences.
:(b) Let &lt;math&gt;d(T, P)&lt;/math&gt; be the minimum edit distance between &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; when no substitutions are allowed (i.e., the only changes are character insertion and deletion). Prove that &lt;math&gt;d(T, P) = |SCS(T, P)| - |LCS(T, P)|&lt;/math&gt; where &lt;math&gt;|SCS(T, P)| (|LCS(T, P)|)&lt;/math&gt; is the size of the shortest SCS (longest LCS) of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;.
[[10.9|Solution]]


:10.10. Suppose you are given &lt;math&gt;n&lt;/math&gt; poker chips stacked in two stacks, where the edges of all chips can be seen. Each chip is one of three colors. A turn consists of choosing a color and removing all chips of that color from the tops of the stacks. The goal is to minimize the number of turns until the chips are gone. 
:For example, consider the stacks &lt;math&gt;(RRGG, GBBB)&lt;/math&gt;. Playing red, green, and then blue suffices to clear the stacks in three moves. Give an &lt;math&gt;O(n^2)&lt;/math&gt; dynamic programming algorithm to find the best strategy for a given pair of chip piles.

===Greedy Algorithms===

:[[10.11]]


:10.12


:[[10.13]]


:10.14


===Number Problems===

:[[10.15]]. You are given a rod of length &lt;math&gt;n&lt;/math&gt; inches and a table of prices obtainable for rod-pieces of size &lt;math&gt;n&lt;/math&gt; or smaller. Give an efficient algorithm to find the maximum value obtainable by cutting up the rod and selling the pieces. For example, if &lt;math&gt;n=8&lt;/math&gt; and the values of different pieces are:
&lt;center&gt;
\begin{array}{|C|rrrrrrrr} length &amp; 1 &amp; 2 &amp; 3 &amp; 4 &amp; 5 &amp; 6 &amp; 7 &amp; 8 \\
\hline
price &amp; 1 &amp; 5 &amp; 8 &amp; 9 &amp; 10 &amp; 17 &amp;17 &amp; 20 \\
\end{array}
&lt;/center&gt;
:then the maximum obtainable value is 22, by cutting into pieces of lengths 2 and 6.
[[10.15|Solution]]


:10.16. Your boss has written an arithmetic expression of n terms to compute your annual bonus, but permits you to parenthesize it however you wish. Give an efficient algorithm to design the parenthesization to maximize the value. For the expression:
&lt;center&gt;&lt;math&gt;6 + 2 * 0 - 4&lt;/math&gt;&lt;/center&gt;
:there exist parenthesizations with values ranging from −32 to 2.


:[[10.17]]. Given a positive integer &lt;math&gt;n&lt;/math&gt;, find an efficient algorithm to compute the smallest number of perfect squares (e.g. 1, 4, 9, 16, . . .) that sum to &lt;math&gt;n&lt;/math&gt;. What is the running time of your algorithm?
[[10.17|Solution]]


:10.18. Given an array &lt;math&gt;A&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find an efficient algorithm to compute the largest sum of a continuous run. For &lt;math&gt;A = [-3, 2, 7, -3, 4, -2, 0, 1]&lt;/math&gt;, the largest such sum is 10, from the second through fifth positions.


:[[10.19]]. Two drivers have to divide up &lt;math&gt;m&lt;/math&gt; suitcases between them, where the weight of the &lt;math&gt;ith&lt;/math&gt; suitcase is &lt;math&gt;w_i&lt;/math&gt;. Give an efficient algorithm to divide up the loads so the two drivers carry equal weight, if possible.
[[10.19|Solution]]


:10.20. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = {s_1, s_2, . . . , s_n}&lt;/math&gt;, and a given target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; that adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, within &lt;math&gt;S = {1, 2, 5, 9, 10}&lt;/math&gt; there is a subset that adds up to &lt;math&gt;T = 22&lt;/math&gt; but not &lt;math&gt;T = 23&lt;/math&gt;.
:Give a dynamic programming algorithm for knapsack that runs in &lt;math&gt;O(nT)&lt;/math&gt; time.


:[[10.21]]


:10.22


:[[10.23]]


:10.24


:[[10.25]]


:10.26

===Graphing Problem===

:[[10.27]]


:10.28


:[[10.29]]


===Design Problems===

:10.30


:[[10.31]]


:10.32


:[[10.33]]


:10.34


:[[10.35]]


:10.36


:[[10.37]]


:10.38


===Interview Problems===

:[[10.39]]


:10.40


:[[10.41]]


Back to [[Chapter List]]</text>
      <sha1>pkta8cq22bu1qxs633tngdh8r516jm2</sha1>
    </revision>
    <revision>
      <id>214</id>
      <parentid>213</parentid>
      <timestamp>2020-09-13T19:54:32Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Greedy Algorithms */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="10832">=Dynamic Programming=

===Elementary Recurrences===

:[[10.1]]. Up to &lt;math&gt;k&lt;/math&gt; steps in a single bound! A child is running up a staircase with &lt;math&gt;n&lt;/math&gt; steps and can hop between 1 and &lt;math&gt;k&lt;/math&gt; steps at a time. Design an algorithm to count how many possible ways the child can run up the stairs, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. What is the running time of your algorithm?
[[10.1|Solution]]


:10.2. Imagine you are a professional thief who plans to rob houses along a street of &lt;math&gt;n&lt;/math&gt; homes. You know the loot at house &lt;math&gt;i&lt;/math&gt; is worth &lt;math&gt;m_i&lt;/math&gt;, for &lt;math&gt;1 \le i \le n&lt;/math&gt;, but you cannot rob neighboring houses because their connected security systems will automatically contact the police if two adjacent houses are broken into. Give an efficient algorithm to determine the maximum amount of money you can steal without alerting the police.


:[[10.3]]. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible mixes (1s,2s,3s) of scoring add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are four possible solutions: (5, 0, 0), (2, 0, 1), (1, 2, 0), and (0, 1, 1).
[[10.3|Solution]]


:10.4. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible scoring sequences add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are thirteen possible sequences, including 1-2-1-1, 3-2, and 1-1-1-1-1.


:[[10.5]]. Given an &lt;math&gt;s * t&lt;/math&gt; grid filled with non-negative numbers, find a path from top left to bottom right that minimizes the sum of all numbers along its path. You can only move either down or right at any point in time.
::(a) Give a solution based on Dijkstra’s algorithm. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
::(b) Give a solution based on dynamic programming. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
[[10.5|Solution]]

===Edit Distance===

:10.6. Typists often make transposition errors exchanging neighboring characters, such as typing “setve” for “steve.” This requires two substitutions to fix under the conventional definition of edit distance.
:Incorporate a swap operation into our edit distance function, so that such neigh-
boring transposition errors can be fixed at the cost of one operation.


:[[10.7]]. Suppose you are given three strings of characters: &lt;math&gt;X&lt;/math&gt;, &lt;math&gt;Y&lt;/math&gt;, and &lt;math&gt;Z&lt;/math&gt;, where &lt;math&gt;|X| = n&lt;/math&gt;, &lt;math&gt;|Y| = m&lt;/math&gt;, and &lt;math&gt;|Z| = n + m&lt;/math&gt;. &lt;math&gt;Z&lt;/math&gt; is said to be a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; iff &lt;math&gt;Z&lt;/math&gt; can be formed by interleaving the characters from &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; in a way that maintains the left-to-right ordering of the characters from each string. 
:(a) Show that cchocohilaptes is a shuffle of chocolate and chips, but chocochilatspe is not.
:(b) Give an efficient dynamic programming algorithm that determines whether &lt;math&gt;Z&lt;/math&gt; is a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt;. (Hint: the values of the dynamic programming matrix you construct should be Boolean, not numeric.)
[[10.7|Solution]]


:10.8. The longest common substring (not subsequence) of two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; is the longest string that appears as a run of consecutive letters in both strings. For example, the longest common substring of photograph and tomography is ograph.
:(a) Let &lt;math&gt;n = |X|&lt;/math&gt; and &lt;math&gt;m = |Y|&lt;/math&gt;. Give a &lt;math&gt;\Theta (nm)&lt;/math&gt; dynamic programming algorithm for longest common substring based on the longest common subsequence/edit distance algorithm.
:(b) Give a simpler &lt;math&gt;\Theta (nm)&lt;/math&gt; algorithm that does not rely on dynamic programming.


:[[10.9]]. The ''longest common subsequence (LCS)'' of two sequences &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the longest sequence &lt;math&gt;L&lt;/math&gt; such that &lt;math&gt;L&lt;/math&gt; is a subsequence of both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;. The ''shortest common supersequence (SCS)'' of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the smallest sequence &lt;math&gt;L&lt;/math&gt; such that both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; are a subsequence of &lt;math&gt;L&lt;/math&gt;.
:(a) Give efficient algorithms to find the LCS and SCS of two given sequences.
:(b) Let &lt;math&gt;d(T, P)&lt;/math&gt; be the minimum edit distance between &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; when no substitutions are allowed (i.e., the only changes are character insertion and deletion). Prove that &lt;math&gt;d(T, P) = |SCS(T, P)| - |LCS(T, P)|&lt;/math&gt; where &lt;math&gt;|SCS(T, P)| (|LCS(T, P)|)&lt;/math&gt; is the size of the shortest SCS (longest LCS) of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;.
[[10.9|Solution]]


:10.10. Suppose you are given &lt;math&gt;n&lt;/math&gt; poker chips stacked in two stacks, where the edges of all chips can be seen. Each chip is one of three colors. A turn consists of choosing a color and removing all chips of that color from the tops of the stacks. The goal is to minimize the number of turns until the chips are gone. 
:For example, consider the stacks &lt;math&gt;(RRGG, GBBB)&lt;/math&gt;. Playing red, green, and then blue suffices to clear the stacks in three moves. Give an &lt;math&gt;O(n^2)&lt;/math&gt; dynamic programming algorithm to find the best strategy for a given pair of chip piles.

===Greedy Algorithms===

:[[10.11]]. Let &lt;math&gt;P_1, P_2, . . . , P_n&lt;/math&gt; be &lt;math&gt;n&lt;/math&gt; programs to be stored on a disk with capacity &lt;math&gt;D&lt;/math&gt; megabytes. Program &lt;math&gt;P_i&lt;/math&gt; requires &lt;math&gt;s_i&lt;/math&gt; megabytes of storage. We cannot store them all because &lt;math&gt;D &lt; \sum_{i=1}^n s_i &lt;/math&gt;
:(a) Does a greedy algorithm that selects programs in order of non-decreasing &lt;math&gt;s_i&lt;/math&gt; maximize the number of programs held on the disk? Prove or give a counter-example.
:(b) Does a greedy algorithm that selects programs in order of non-increasing &lt;math&gt;s_i&lt;/math&gt; use as much of the capacity of the disk as possible? Prove or give a counter-example.
[[10.11|Solution]]


:10.12. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We seek an algorithm to make change of &lt;math&gt;n&lt;/math&gt; units using the minimum number of this country’s coins.
:(a) The greedy algorithm repeatedly selects the biggest coin no bigger than the amount to be changed and repeats until it is zero. Show that the greedy algorithm does not always use the minimum number of coins in a country whose denominations are {1, 6, 10}.
:(b) Give an efficient algorithm that correctly determines the minimum number of coins needed to make change of &lt;math&gt;n&lt;/math&gt; units using denominations &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt;. Analyze its running time.


:[[10.13]]. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We want to count how many distinct ways &lt;math&gt;C(n)&lt;/math&gt; there are to make change of &lt;math&gt;n&lt;/math&gt; units. For example, in a country whose denominations are {1, 6, 10}, &lt;math&gt;C(5) = 1&lt;/math&gt;, &lt;math&gt;C(6)&lt;/math&gt; to &lt;math&gt;C(9) = 2&lt;/math&gt;, &lt;math&gt;C(10) = 3&lt;/math&gt;, and &lt;math&gt;C(12) = 4&lt;/math&gt;.
:(a) How many ways are there to make change of 20 units from {1, 6, 10}?
:(b) Give an efficient algorithm to compute &lt;math&gt;C(n)&lt;/math&gt;, and analyze its complexity. (Hint: think in terms of computing &lt;math&gt;C(n, d)&lt;/math&gt;, the number of ways to make change of &lt;math&gt;n&lt;/math&gt; units with highest denomination &lt;math&gt;d&lt;/math&gt;. Be careful to avoid overcounting.)
[[10.13|Solution]]


:10.14. In the single-processor scheduling problem, we are given a set of &lt;math&gt;n&lt;/math&gt; jobs &lt;math&gt;J&lt;/math&gt;. Each job &lt;math&gt;i&lt;/math&gt; has a processing time &lt;math&gt;t_i&lt;/math&gt;, and a deadline &lt;math&gt;d_i&lt;/math&gt;. A feasible schedule is a permutation of the jobs such that when the jobs are performed in that order, every job is finished before its deadline. The greedy algorithm for single-processor scheduling selects the job with the earliest deadline first.
:Show that if a feasible schedule exists, then the schedule produced by this greedy algorithm is feasible.

===Number Problems===

:[[10.15]]. You are given a rod of length &lt;math&gt;n&lt;/math&gt; inches and a table of prices obtainable for rod-pieces of size &lt;math&gt;n&lt;/math&gt; or smaller. Give an efficient algorithm to find the maximum value obtainable by cutting up the rod and selling the pieces. For example, if &lt;math&gt;n=8&lt;/math&gt; and the values of different pieces are:
&lt;center&gt;
\begin{array}{|C|rrrrrrrr} length &amp; 1 &amp; 2 &amp; 3 &amp; 4 &amp; 5 &amp; 6 &amp; 7 &amp; 8 \\
\hline
price &amp; 1 &amp; 5 &amp; 8 &amp; 9 &amp; 10 &amp; 17 &amp;17 &amp; 20 \\
\end{array}
&lt;/center&gt;
:then the maximum obtainable value is 22, by cutting into pieces of lengths 2 and 6.
[[10.15|Solution]]


:10.16. Your boss has written an arithmetic expression of n terms to compute your annual bonus, but permits you to parenthesize it however you wish. Give an efficient algorithm to design the parenthesization to maximize the value. For the expression:
&lt;center&gt;&lt;math&gt;6 + 2 * 0 - 4&lt;/math&gt;&lt;/center&gt;
:there exist parenthesizations with values ranging from −32 to 2.


:[[10.17]]. Given a positive integer &lt;math&gt;n&lt;/math&gt;, find an efficient algorithm to compute the smallest number of perfect squares (e.g. 1, 4, 9, 16, . . .) that sum to &lt;math&gt;n&lt;/math&gt;. What is the running time of your algorithm?
[[10.17|Solution]]


:10.18. Given an array &lt;math&gt;A&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find an efficient algorithm to compute the largest sum of a continuous run. For &lt;math&gt;A = [-3, 2, 7, -3, 4, -2, 0, 1]&lt;/math&gt;, the largest such sum is 10, from the second through fifth positions.


:[[10.19]]. Two drivers have to divide up &lt;math&gt;m&lt;/math&gt; suitcases between them, where the weight of the &lt;math&gt;ith&lt;/math&gt; suitcase is &lt;math&gt;w_i&lt;/math&gt;. Give an efficient algorithm to divide up the loads so the two drivers carry equal weight, if possible.
[[10.19|Solution]]


:10.20. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = {s_1, s_2, . . . , s_n}&lt;/math&gt;, and a given target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; that adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, within &lt;math&gt;S = {1, 2, 5, 9, 10}&lt;/math&gt; there is a subset that adds up to &lt;math&gt;T = 22&lt;/math&gt; but not &lt;math&gt;T = 23&lt;/math&gt;.
:Give a dynamic programming algorithm for knapsack that runs in &lt;math&gt;O(nT)&lt;/math&gt; time.


:[[10.21]]


:10.22


:[[10.23]]


:10.24


:[[10.25]]


:10.26

===Graphing Problem===

:[[10.27]]


:10.28


:[[10.29]]


===Design Problems===

:10.30


:[[10.31]]


:10.32


:[[10.33]]


:10.34


:[[10.35]]


:10.36


:[[10.37]]


:10.38


===Interview Problems===

:[[10.39]]


:10.40


:[[10.41]]


Back to [[Chapter List]]</text>
      <sha1>mh9omkit5t6nk91la9ew1nqoxo3nxdf</sha1>
    </revision>
    <revision>
      <id>215</id>
      <parentid>214</parentid>
      <timestamp>2020-09-13T20:18:37Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Number Problems */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="15172">=Dynamic Programming=

===Elementary Recurrences===

:[[10.1]]. Up to &lt;math&gt;k&lt;/math&gt; steps in a single bound! A child is running up a staircase with &lt;math&gt;n&lt;/math&gt; steps and can hop between 1 and &lt;math&gt;k&lt;/math&gt; steps at a time. Design an algorithm to count how many possible ways the child can run up the stairs, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. What is the running time of your algorithm?
[[10.1|Solution]]


:10.2. Imagine you are a professional thief who plans to rob houses along a street of &lt;math&gt;n&lt;/math&gt; homes. You know the loot at house &lt;math&gt;i&lt;/math&gt; is worth &lt;math&gt;m_i&lt;/math&gt;, for &lt;math&gt;1 \le i \le n&lt;/math&gt;, but you cannot rob neighboring houses because their connected security systems will automatically contact the police if two adjacent houses are broken into. Give an efficient algorithm to determine the maximum amount of money you can steal without alerting the police.


:[[10.3]]. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible mixes (1s,2s,3s) of scoring add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are four possible solutions: (5, 0, 0), (2, 0, 1), (1, 2, 0), and (0, 1, 1).
[[10.3|Solution]]


:10.4. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible scoring sequences add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are thirteen possible sequences, including 1-2-1-1, 3-2, and 1-1-1-1-1.


:[[10.5]]. Given an &lt;math&gt;s * t&lt;/math&gt; grid filled with non-negative numbers, find a path from top left to bottom right that minimizes the sum of all numbers along its path. You can only move either down or right at any point in time.
::(a) Give a solution based on Dijkstra’s algorithm. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
::(b) Give a solution based on dynamic programming. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
[[10.5|Solution]]

===Edit Distance===

:10.6. Typists often make transposition errors exchanging neighboring characters, such as typing “setve” for “steve.” This requires two substitutions to fix under the conventional definition of edit distance.
:Incorporate a swap operation into our edit distance function, so that such neigh-
boring transposition errors can be fixed at the cost of one operation.


:[[10.7]]. Suppose you are given three strings of characters: &lt;math&gt;X&lt;/math&gt;, &lt;math&gt;Y&lt;/math&gt;, and &lt;math&gt;Z&lt;/math&gt;, where &lt;math&gt;|X| = n&lt;/math&gt;, &lt;math&gt;|Y| = m&lt;/math&gt;, and &lt;math&gt;|Z| = n + m&lt;/math&gt;. &lt;math&gt;Z&lt;/math&gt; is said to be a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; iff &lt;math&gt;Z&lt;/math&gt; can be formed by interleaving the characters from &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; in a way that maintains the left-to-right ordering of the characters from each string. 
:(a) Show that cchocohilaptes is a shuffle of chocolate and chips, but chocochilatspe is not.
:(b) Give an efficient dynamic programming algorithm that determines whether &lt;math&gt;Z&lt;/math&gt; is a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt;. (Hint: the values of the dynamic programming matrix you construct should be Boolean, not numeric.)
[[10.7|Solution]]


:10.8. The longest common substring (not subsequence) of two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; is the longest string that appears as a run of consecutive letters in both strings. For example, the longest common substring of photograph and tomography is ograph.
:(a) Let &lt;math&gt;n = |X|&lt;/math&gt; and &lt;math&gt;m = |Y|&lt;/math&gt;. Give a &lt;math&gt;\Theta (nm)&lt;/math&gt; dynamic programming algorithm for longest common substring based on the longest common subsequence/edit distance algorithm.
:(b) Give a simpler &lt;math&gt;\Theta (nm)&lt;/math&gt; algorithm that does not rely on dynamic programming.


:[[10.9]]. The ''longest common subsequence (LCS)'' of two sequences &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the longest sequence &lt;math&gt;L&lt;/math&gt; such that &lt;math&gt;L&lt;/math&gt; is a subsequence of both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;. The ''shortest common supersequence (SCS)'' of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the smallest sequence &lt;math&gt;L&lt;/math&gt; such that both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; are a subsequence of &lt;math&gt;L&lt;/math&gt;.
:(a) Give efficient algorithms to find the LCS and SCS of two given sequences.
:(b) Let &lt;math&gt;d(T, P)&lt;/math&gt; be the minimum edit distance between &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; when no substitutions are allowed (i.e., the only changes are character insertion and deletion). Prove that &lt;math&gt;d(T, P) = |SCS(T, P)| - |LCS(T, P)|&lt;/math&gt; where &lt;math&gt;|SCS(T, P)| (|LCS(T, P)|)&lt;/math&gt; is the size of the shortest SCS (longest LCS) of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;.
[[10.9|Solution]]


:10.10. Suppose you are given &lt;math&gt;n&lt;/math&gt; poker chips stacked in two stacks, where the edges of all chips can be seen. Each chip is one of three colors. A turn consists of choosing a color and removing all chips of that color from the tops of the stacks. The goal is to minimize the number of turns until the chips are gone. 
:For example, consider the stacks &lt;math&gt;(RRGG, GBBB)&lt;/math&gt;. Playing red, green, and then blue suffices to clear the stacks in three moves. Give an &lt;math&gt;O(n^2)&lt;/math&gt; dynamic programming algorithm to find the best strategy for a given pair of chip piles.

===Greedy Algorithms===

:[[10.11]]. Let &lt;math&gt;P_1, P_2, . . . , P_n&lt;/math&gt; be &lt;math&gt;n&lt;/math&gt; programs to be stored on a disk with capacity &lt;math&gt;D&lt;/math&gt; megabytes. Program &lt;math&gt;P_i&lt;/math&gt; requires &lt;math&gt;s_i&lt;/math&gt; megabytes of storage. We cannot store them all because &lt;math&gt;D &lt; \sum_{i=1}^n s_i &lt;/math&gt;
:(a) Does a greedy algorithm that selects programs in order of non-decreasing &lt;math&gt;s_i&lt;/math&gt; maximize the number of programs held on the disk? Prove or give a counter-example.
:(b) Does a greedy algorithm that selects programs in order of non-increasing &lt;math&gt;s_i&lt;/math&gt; use as much of the capacity of the disk as possible? Prove or give a counter-example.
[[10.11|Solution]]


:10.12. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We seek an algorithm to make change of &lt;math&gt;n&lt;/math&gt; units using the minimum number of this country’s coins.
:(a) The greedy algorithm repeatedly selects the biggest coin no bigger than the amount to be changed and repeats until it is zero. Show that the greedy algorithm does not always use the minimum number of coins in a country whose denominations are {1, 6, 10}.
:(b) Give an efficient algorithm that correctly determines the minimum number of coins needed to make change of &lt;math&gt;n&lt;/math&gt; units using denominations &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt;. Analyze its running time.


:[[10.13]]. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We want to count how many distinct ways &lt;math&gt;C(n)&lt;/math&gt; there are to make change of &lt;math&gt;n&lt;/math&gt; units. For example, in a country whose denominations are {1, 6, 10}, &lt;math&gt;C(5) = 1&lt;/math&gt;, &lt;math&gt;C(6)&lt;/math&gt; to &lt;math&gt;C(9) = 2&lt;/math&gt;, &lt;math&gt;C(10) = 3&lt;/math&gt;, and &lt;math&gt;C(12) = 4&lt;/math&gt;.
:(a) How many ways are there to make change of 20 units from {1, 6, 10}?
:(b) Give an efficient algorithm to compute &lt;math&gt;C(n)&lt;/math&gt;, and analyze its complexity. (Hint: think in terms of computing &lt;math&gt;C(n, d)&lt;/math&gt;, the number of ways to make change of &lt;math&gt;n&lt;/math&gt; units with highest denomination &lt;math&gt;d&lt;/math&gt;. Be careful to avoid overcounting.)
[[10.13|Solution]]


:10.14. In the single-processor scheduling problem, we are given a set of &lt;math&gt;n&lt;/math&gt; jobs &lt;math&gt;J&lt;/math&gt;. Each job &lt;math&gt;i&lt;/math&gt; has a processing time &lt;math&gt;t_i&lt;/math&gt;, and a deadline &lt;math&gt;d_i&lt;/math&gt;. A feasible schedule is a permutation of the jobs such that when the jobs are performed in that order, every job is finished before its deadline. The greedy algorithm for single-processor scheduling selects the job with the earliest deadline first.
:Show that if a feasible schedule exists, then the schedule produced by this greedy algorithm is feasible.

===Number Problems===

:[[10.15]]. You are given a rod of length &lt;math&gt;n&lt;/math&gt; inches and a table of prices obtainable for rod-pieces of size &lt;math&gt;n&lt;/math&gt; or smaller. Give an efficient algorithm to find the maximum value obtainable by cutting up the rod and selling the pieces. For example, if &lt;math&gt;n=8&lt;/math&gt; and the values of different pieces are:
&lt;center&gt;
\begin{array}{|C|rrrrrrrr} length &amp; 1 &amp; 2 &amp; 3 &amp; 4 &amp; 5 &amp; 6 &amp; 7 &amp; 8 \\
\hline
price &amp; 1 &amp; 5 &amp; 8 &amp; 9 &amp; 10 &amp; 17 &amp;17 &amp; 20 \\
\end{array}
&lt;/center&gt;
:then the maximum obtainable value is 22, by cutting into pieces of lengths 2 and 6.
[[10.15|Solution]]


:10.16. Your boss has written an arithmetic expression of n terms to compute your annual bonus, but permits you to parenthesize it however you wish. Give an efficient algorithm to design the parenthesization to maximize the value. For the expression:
&lt;center&gt;&lt;math&gt;6 + 2 * 0 - 4&lt;/math&gt;&lt;/center&gt;
:there exist parenthesizations with values ranging from −32 to 2.


:[[10.17]]. Given a positive integer &lt;math&gt;n&lt;/math&gt;, find an efficient algorithm to compute the smallest number of perfect squares (e.g. 1, 4, 9, 16, . . .) that sum to &lt;math&gt;n&lt;/math&gt;. What is the running time of your algorithm?
[[10.17|Solution]]


:10.18. Given an array &lt;math&gt;A&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find an efficient algorithm to compute the largest sum of a continuous run. For &lt;math&gt;A = [-3, 2, 7, -3, 4, -2, 0, 1]&lt;/math&gt;, the largest such sum is 10, from the second through fifth positions.


:[[10.19]]. Two drivers have to divide up &lt;math&gt;m&lt;/math&gt; suitcases between them, where the weight of the &lt;math&gt;ith&lt;/math&gt; suitcase is &lt;math&gt;w_i&lt;/math&gt;. Give an efficient algorithm to divide up the loads so the two drivers carry equal weight, if possible.
[[10.19|Solution]]


:10.20. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = {s_1, s_2, . . . , s_n}&lt;/math&gt;, and a given target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; that adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, within &lt;math&gt;S = {1, 2, 5, 9, 10}&lt;/math&gt; there is a subset that adds up to &lt;math&gt;T = 22&lt;/math&gt; but not &lt;math&gt;T = 23&lt;/math&gt;.
:Give a dynamic programming algorithm for knapsack that runs in &lt;math&gt;O(nT)&lt;/math&gt; time.


:[[10.21]]. The integer partition takes a set of positive integers &lt;math&gt;S = {s_1, . . . , s_n}&lt;/math&gt; and seeks a subset &lt;math&gt;I \subset S&lt;/math&gt; such that
&lt;center&gt;&lt;math&gt; \sum_{i \in I} s_i = \sum_{i \notin I} s_i&lt;/math&gt;&lt;/center&gt;
:Let &lt;math&gt; \sum_{i \in S} s_i = M &lt;/math&gt;. Give an &lt;math&gt;O(nM)&lt;/math&gt; dynamic programming algorithm to solve the integer partition problem.
[[10.21|Solution]]


:10.22. Assume that there are n numbers (some possibly negative) on a circle, and we wish to find the maximum contiguous sum along an arc of the circle. Give an efficient algorithm for solving this problem.


:[[10.23]]. A certain string processing language allows the programmer to break a string into two pieces. It costs &lt;math&gt;n&lt;/math&gt; units of time to break a string of &lt;math&gt;n&lt;/math&gt; characters into two pieces, since this involves copying the old string. A programmer wants to break a string into many pieces, and the order in which the breaks are made can affect the total amount of time used. For example, suppose we wish to break a 20-character string after characters 3, 8, and 10. If the breaks are made in left-to-right order, then the first break costs 20 units of time, the second break costs 17 units of time, and the third break costs 12 units of time, for a total of 49 units. If the breaks are made in right-to-left order, the first break costs 20 units of time, the second break costs 10 units of time, and the third break costs 8 units of time, for a total of only 38 units.
:Give a dynamic programming algorithm that takes a list of character positions after which to break and determines the cheapest break cost in &lt;math&gt;O(n^3)&lt;/math&gt; time.
[[10.23|Solution]]


:10.24. Consider the following data compression technique. We have a table of &lt;math&gt;m&lt;/math&gt; text strings, each at most &lt;math&gt;k&lt;/math&gt; in length. We want to encode a data string &lt;math&gt;D&lt;/math&gt; of length &lt;math&gt;n&lt;/math&gt; using as few text strings as possible. For example, if our table contains &lt;math&gt;(a,ba,abab,b)&lt;/math&gt; and the data string is &lt;math&gt;bababbaababa&lt;/math&gt;, the best way to encode it is &lt;math&gt;(b,abab,ba,abab,a)-a&lt;/math&gt; total of five code words. Give an &lt;math&gt;O(nmk)&lt;/math&gt; algorithm to find the length of the best encoding. You may assume that every string has at least one encoding in terms of the table.


:[[10.25]]. The traditional world chess championship is a match of 24 games. The current champion retains the title in case the match is a tie. Each game ends in a win, loss, or draw (tie) where wins count as 1, losses as 0, and draws as &lt;math&gt;1/2&lt;/math&gt;. The players take turns playing white and black. White plays first and so has an advantage. The champion plays white in the first game. The champ has probabilities &lt;math&gt;w_w&lt;/math&gt;, &lt;math&gt;w_d&lt;/math&gt;, and &lt;math&gt;w_l&lt;/math&gt; of winning, drawing, and losing playing white, and has probabilities &lt;math&gt;b_w&lt;/math&gt;, &lt;math&gt;b_d&lt;/math&gt;, and &lt;math&gt;b_l&lt;/math&gt; of winning, drawing, and losing playing black.
:(a) Write a recurrence for the probability that the champion retains the title. Assume that there are &lt;math&gt;g&lt;/math&gt; games left to play in the match and that the champion needs to get &lt;math&gt;i&lt;/math&gt; points (which may be a multiple of &lt;math&gt;1/2&lt;/math&gt;).
:(b) Based on your recurrence, give a dynamic programming algorithm to calculate the champion’s probability of retaining the title.
:(c) Analyze its running time for an &lt;math&gt;n&lt;/math&gt; game match.
[[10.125|Solution]]


:10.26. Eggs break when dropped from great enough height. Specifically, there must be a floor &lt;math&gt;f&lt;/math&gt; in any sufficiently tall building such that an egg dropped from the &lt;math&gt;f&lt;/math&gt;th floor breaks, but one dropped from the &lt;math&gt;(f - 1)&lt;/math&gt;st floor will not. If the egg always breaks, then &lt;math&gt;f = 1&lt;/math&gt;. If the egg never breaks, then &lt;math&gt;f = n + 1&lt;/math&gt;. 
:You seek to find the critical floor &lt;math&gt;f&lt;/math&gt; using an &lt;math&gt;n-floor&lt;/math&gt; building. The only operation you can perform is to drop an egg off some floor and see what happens. You start out with &lt;math&gt;k&lt;/math&gt; eggs, and seek to make as few drops as possible. Broken eggs cannot be reused. Let &lt;math&gt;E(k, n)&lt;/math&gt; be the minimum number of egg drops that will always suffice.
:(a) Show that &lt;math&gt;E(1, n) = n&lt;/math&gt;.
:(b) Show that &lt;math&gt;E(k, n) = \Theta (n^{1/k})&lt;/math&gt;.
:(c) Find a recurrence for &lt;math&gt;E(k, n)&lt;/math&gt;. What is the running time of the dynamic program to find &lt;math&gt;E(k, n)&lt;/math&gt;?

===Graphing Problem===

:[[10.27]]


:10.28


:[[10.29]]


===Design Problems===

:10.30


:[[10.31]]


:10.32


:[[10.33]]


:10.34


:[[10.35]]


:10.36


:[[10.37]]


:10.38


===Interview Problems===

:[[10.39]]


:10.40


:[[10.41]]


Back to [[Chapter List]]</text>
      <sha1>ogmrtr4nf9f239tz4cin9ykponqbmc2</sha1>
    </revision>
    <revision>
      <id>216</id>
      <parentid>215</parentid>
      <timestamp>2020-09-13T20:26:41Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Graphing Problem */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="17458">=Dynamic Programming=

===Elementary Recurrences===

:[[10.1]]. Up to &lt;math&gt;k&lt;/math&gt; steps in a single bound! A child is running up a staircase with &lt;math&gt;n&lt;/math&gt; steps and can hop between 1 and &lt;math&gt;k&lt;/math&gt; steps at a time. Design an algorithm to count how many possible ways the child can run up the stairs, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. What is the running time of your algorithm?
[[10.1|Solution]]


:10.2. Imagine you are a professional thief who plans to rob houses along a street of &lt;math&gt;n&lt;/math&gt; homes. You know the loot at house &lt;math&gt;i&lt;/math&gt; is worth &lt;math&gt;m_i&lt;/math&gt;, for &lt;math&gt;1 \le i \le n&lt;/math&gt;, but you cannot rob neighboring houses because their connected security systems will automatically contact the police if two adjacent houses are broken into. Give an efficient algorithm to determine the maximum amount of money you can steal without alerting the police.


:[[10.3]]. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible mixes (1s,2s,3s) of scoring add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are four possible solutions: (5, 0, 0), (2, 0, 1), (1, 2, 0), and (0, 1, 1).
[[10.3|Solution]]


:10.4. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible scoring sequences add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are thirteen possible sequences, including 1-2-1-1, 3-2, and 1-1-1-1-1.


:[[10.5]]. Given an &lt;math&gt;s * t&lt;/math&gt; grid filled with non-negative numbers, find a path from top left to bottom right that minimizes the sum of all numbers along its path. You can only move either down or right at any point in time.
::(a) Give a solution based on Dijkstra’s algorithm. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
::(b) Give a solution based on dynamic programming. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
[[10.5|Solution]]

===Edit Distance===

:10.6. Typists often make transposition errors exchanging neighboring characters, such as typing “setve” for “steve.” This requires two substitutions to fix under the conventional definition of edit distance.
:Incorporate a swap operation into our edit distance function, so that such neigh-
boring transposition errors can be fixed at the cost of one operation.


:[[10.7]]. Suppose you are given three strings of characters: &lt;math&gt;X&lt;/math&gt;, &lt;math&gt;Y&lt;/math&gt;, and &lt;math&gt;Z&lt;/math&gt;, where &lt;math&gt;|X| = n&lt;/math&gt;, &lt;math&gt;|Y| = m&lt;/math&gt;, and &lt;math&gt;|Z| = n + m&lt;/math&gt;. &lt;math&gt;Z&lt;/math&gt; is said to be a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; iff &lt;math&gt;Z&lt;/math&gt; can be formed by interleaving the characters from &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; in a way that maintains the left-to-right ordering of the characters from each string. 
:(a) Show that cchocohilaptes is a shuffle of chocolate and chips, but chocochilatspe is not.
:(b) Give an efficient dynamic programming algorithm that determines whether &lt;math&gt;Z&lt;/math&gt; is a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt;. (Hint: the values of the dynamic programming matrix you construct should be Boolean, not numeric.)
[[10.7|Solution]]


:10.8. The longest common substring (not subsequence) of two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; is the longest string that appears as a run of consecutive letters in both strings. For example, the longest common substring of photograph and tomography is ograph.
:(a) Let &lt;math&gt;n = |X|&lt;/math&gt; and &lt;math&gt;m = |Y|&lt;/math&gt;. Give a &lt;math&gt;\Theta (nm)&lt;/math&gt; dynamic programming algorithm for longest common substring based on the longest common subsequence/edit distance algorithm.
:(b) Give a simpler &lt;math&gt;\Theta (nm)&lt;/math&gt; algorithm that does not rely on dynamic programming.


:[[10.9]]. The ''longest common subsequence (LCS)'' of two sequences &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the longest sequence &lt;math&gt;L&lt;/math&gt; such that &lt;math&gt;L&lt;/math&gt; is a subsequence of both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;. The ''shortest common supersequence (SCS)'' of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the smallest sequence &lt;math&gt;L&lt;/math&gt; such that both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; are a subsequence of &lt;math&gt;L&lt;/math&gt;.
:(a) Give efficient algorithms to find the LCS and SCS of two given sequences.
:(b) Let &lt;math&gt;d(T, P)&lt;/math&gt; be the minimum edit distance between &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; when no substitutions are allowed (i.e., the only changes are character insertion and deletion). Prove that &lt;math&gt;d(T, P) = |SCS(T, P)| - |LCS(T, P)|&lt;/math&gt; where &lt;math&gt;|SCS(T, P)| (|LCS(T, P)|)&lt;/math&gt; is the size of the shortest SCS (longest LCS) of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;.
[[10.9|Solution]]


:10.10. Suppose you are given &lt;math&gt;n&lt;/math&gt; poker chips stacked in two stacks, where the edges of all chips can be seen. Each chip is one of three colors. A turn consists of choosing a color and removing all chips of that color from the tops of the stacks. The goal is to minimize the number of turns until the chips are gone. 
:For example, consider the stacks &lt;math&gt;(RRGG, GBBB)&lt;/math&gt;. Playing red, green, and then blue suffices to clear the stacks in three moves. Give an &lt;math&gt;O(n^2)&lt;/math&gt; dynamic programming algorithm to find the best strategy for a given pair of chip piles.

===Greedy Algorithms===

:[[10.11]]. Let &lt;math&gt;P_1, P_2, . . . , P_n&lt;/math&gt; be &lt;math&gt;n&lt;/math&gt; programs to be stored on a disk with capacity &lt;math&gt;D&lt;/math&gt; megabytes. Program &lt;math&gt;P_i&lt;/math&gt; requires &lt;math&gt;s_i&lt;/math&gt; megabytes of storage. We cannot store them all because &lt;math&gt;D &lt; \sum_{i=1}^n s_i &lt;/math&gt;
:(a) Does a greedy algorithm that selects programs in order of non-decreasing &lt;math&gt;s_i&lt;/math&gt; maximize the number of programs held on the disk? Prove or give a counter-example.
:(b) Does a greedy algorithm that selects programs in order of non-increasing &lt;math&gt;s_i&lt;/math&gt; use as much of the capacity of the disk as possible? Prove or give a counter-example.
[[10.11|Solution]]


:10.12. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We seek an algorithm to make change of &lt;math&gt;n&lt;/math&gt; units using the minimum number of this country’s coins.
:(a) The greedy algorithm repeatedly selects the biggest coin no bigger than the amount to be changed and repeats until it is zero. Show that the greedy algorithm does not always use the minimum number of coins in a country whose denominations are {1, 6, 10}.
:(b) Give an efficient algorithm that correctly determines the minimum number of coins needed to make change of &lt;math&gt;n&lt;/math&gt; units using denominations &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt;. Analyze its running time.


:[[10.13]]. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We want to count how many distinct ways &lt;math&gt;C(n)&lt;/math&gt; there are to make change of &lt;math&gt;n&lt;/math&gt; units. For example, in a country whose denominations are {1, 6, 10}, &lt;math&gt;C(5) = 1&lt;/math&gt;, &lt;math&gt;C(6)&lt;/math&gt; to &lt;math&gt;C(9) = 2&lt;/math&gt;, &lt;math&gt;C(10) = 3&lt;/math&gt;, and &lt;math&gt;C(12) = 4&lt;/math&gt;.
:(a) How many ways are there to make change of 20 units from {1, 6, 10}?
:(b) Give an efficient algorithm to compute &lt;math&gt;C(n)&lt;/math&gt;, and analyze its complexity. (Hint: think in terms of computing &lt;math&gt;C(n, d)&lt;/math&gt;, the number of ways to make change of &lt;math&gt;n&lt;/math&gt; units with highest denomination &lt;math&gt;d&lt;/math&gt;. Be careful to avoid overcounting.)
[[10.13|Solution]]


:10.14. In the single-processor scheduling problem, we are given a set of &lt;math&gt;n&lt;/math&gt; jobs &lt;math&gt;J&lt;/math&gt;. Each job &lt;math&gt;i&lt;/math&gt; has a processing time &lt;math&gt;t_i&lt;/math&gt;, and a deadline &lt;math&gt;d_i&lt;/math&gt;. A feasible schedule is a permutation of the jobs such that when the jobs are performed in that order, every job is finished before its deadline. The greedy algorithm for single-processor scheduling selects the job with the earliest deadline first.
:Show that if a feasible schedule exists, then the schedule produced by this greedy algorithm is feasible.

===Number Problems===

:[[10.15]]. You are given a rod of length &lt;math&gt;n&lt;/math&gt; inches and a table of prices obtainable for rod-pieces of size &lt;math&gt;n&lt;/math&gt; or smaller. Give an efficient algorithm to find the maximum value obtainable by cutting up the rod and selling the pieces. For example, if &lt;math&gt;n=8&lt;/math&gt; and the values of different pieces are:
&lt;center&gt;
\begin{array}{|C|rrrrrrrr} length &amp; 1 &amp; 2 &amp; 3 &amp; 4 &amp; 5 &amp; 6 &amp; 7 &amp; 8 \\
\hline
price &amp; 1 &amp; 5 &amp; 8 &amp; 9 &amp; 10 &amp; 17 &amp;17 &amp; 20 \\
\end{array}
&lt;/center&gt;
:then the maximum obtainable value is 22, by cutting into pieces of lengths 2 and 6.
[[10.15|Solution]]


:10.16. Your boss has written an arithmetic expression of n terms to compute your annual bonus, but permits you to parenthesize it however you wish. Give an efficient algorithm to design the parenthesization to maximize the value. For the expression:
&lt;center&gt;&lt;math&gt;6 + 2 * 0 - 4&lt;/math&gt;&lt;/center&gt;
:there exist parenthesizations with values ranging from −32 to 2.


:[[10.17]]. Given a positive integer &lt;math&gt;n&lt;/math&gt;, find an efficient algorithm to compute the smallest number of perfect squares (e.g. 1, 4, 9, 16, . . .) that sum to &lt;math&gt;n&lt;/math&gt;. What is the running time of your algorithm?
[[10.17|Solution]]


:10.18. Given an array &lt;math&gt;A&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find an efficient algorithm to compute the largest sum of a continuous run. For &lt;math&gt;A = [-3, 2, 7, -3, 4, -2, 0, 1]&lt;/math&gt;, the largest such sum is 10, from the second through fifth positions.


:[[10.19]]. Two drivers have to divide up &lt;math&gt;m&lt;/math&gt; suitcases between them, where the weight of the &lt;math&gt;ith&lt;/math&gt; suitcase is &lt;math&gt;w_i&lt;/math&gt;. Give an efficient algorithm to divide up the loads so the two drivers carry equal weight, if possible.
[[10.19|Solution]]


:10.20. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = {s_1, s_2, . . . , s_n}&lt;/math&gt;, and a given target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; that adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, within &lt;math&gt;S = {1, 2, 5, 9, 10}&lt;/math&gt; there is a subset that adds up to &lt;math&gt;T = 22&lt;/math&gt; but not &lt;math&gt;T = 23&lt;/math&gt;.
:Give a dynamic programming algorithm for knapsack that runs in &lt;math&gt;O(nT)&lt;/math&gt; time.


:[[10.21]]. The integer partition takes a set of positive integers &lt;math&gt;S = {s_1, . . . , s_n}&lt;/math&gt; and seeks a subset &lt;math&gt;I \subset S&lt;/math&gt; such that
&lt;center&gt;&lt;math&gt; \sum_{i \in I} s_i = \sum_{i \notin I} s_i&lt;/math&gt;&lt;/center&gt;
:Let &lt;math&gt; \sum_{i \in S} s_i = M &lt;/math&gt;. Give an &lt;math&gt;O(nM)&lt;/math&gt; dynamic programming algorithm to solve the integer partition problem.
[[10.21|Solution]]


:10.22. Assume that there are n numbers (some possibly negative) on a circle, and we wish to find the maximum contiguous sum along an arc of the circle. Give an efficient algorithm for solving this problem.


:[[10.23]]. A certain string processing language allows the programmer to break a string into two pieces. It costs &lt;math&gt;n&lt;/math&gt; units of time to break a string of &lt;math&gt;n&lt;/math&gt; characters into two pieces, since this involves copying the old string. A programmer wants to break a string into many pieces, and the order in which the breaks are made can affect the total amount of time used. For example, suppose we wish to break a 20-character string after characters 3, 8, and 10. If the breaks are made in left-to-right order, then the first break costs 20 units of time, the second break costs 17 units of time, and the third break costs 12 units of time, for a total of 49 units. If the breaks are made in right-to-left order, the first break costs 20 units of time, the second break costs 10 units of time, and the third break costs 8 units of time, for a total of only 38 units.
:Give a dynamic programming algorithm that takes a list of character positions after which to break and determines the cheapest break cost in &lt;math&gt;O(n^3)&lt;/math&gt; time.
[[10.23|Solution]]


:10.24. Consider the following data compression technique. We have a table of &lt;math&gt;m&lt;/math&gt; text strings, each at most &lt;math&gt;k&lt;/math&gt; in length. We want to encode a data string &lt;math&gt;D&lt;/math&gt; of length &lt;math&gt;n&lt;/math&gt; using as few text strings as possible. For example, if our table contains &lt;math&gt;(a,ba,abab,b)&lt;/math&gt; and the data string is &lt;math&gt;bababbaababa&lt;/math&gt;, the best way to encode it is &lt;math&gt;(b,abab,ba,abab,a)-a&lt;/math&gt; total of five code words. Give an &lt;math&gt;O(nmk)&lt;/math&gt; algorithm to find the length of the best encoding. You may assume that every string has at least one encoding in terms of the table.


:[[10.25]]. The traditional world chess championship is a match of 24 games. The current champion retains the title in case the match is a tie. Each game ends in a win, loss, or draw (tie) where wins count as 1, losses as 0, and draws as &lt;math&gt;1/2&lt;/math&gt;. The players take turns playing white and black. White plays first and so has an advantage. The champion plays white in the first game. The champ has probabilities &lt;math&gt;w_w&lt;/math&gt;, &lt;math&gt;w_d&lt;/math&gt;, and &lt;math&gt;w_l&lt;/math&gt; of winning, drawing, and losing playing white, and has probabilities &lt;math&gt;b_w&lt;/math&gt;, &lt;math&gt;b_d&lt;/math&gt;, and &lt;math&gt;b_l&lt;/math&gt; of winning, drawing, and losing playing black.
:(a) Write a recurrence for the probability that the champion retains the title. Assume that there are &lt;math&gt;g&lt;/math&gt; games left to play in the match and that the champion needs to get &lt;math&gt;i&lt;/math&gt; points (which may be a multiple of &lt;math&gt;1/2&lt;/math&gt;).
:(b) Based on your recurrence, give a dynamic programming algorithm to calculate the champion’s probability of retaining the title.
:(c) Analyze its running time for an &lt;math&gt;n&lt;/math&gt; game match.
[[10.125|Solution]]


:10.26. Eggs break when dropped from great enough height. Specifically, there must be a floor &lt;math&gt;f&lt;/math&gt; in any sufficiently tall building such that an egg dropped from the &lt;math&gt;f&lt;/math&gt;th floor breaks, but one dropped from the &lt;math&gt;(f - 1)&lt;/math&gt;st floor will not. If the egg always breaks, then &lt;math&gt;f = 1&lt;/math&gt;. If the egg never breaks, then &lt;math&gt;f = n + 1&lt;/math&gt;. 
:You seek to find the critical floor &lt;math&gt;f&lt;/math&gt; using an &lt;math&gt;n-floor&lt;/math&gt; building. The only operation you can perform is to drop an egg off some floor and see what happens. You start out with &lt;math&gt;k&lt;/math&gt; eggs, and seek to make as few drops as possible. Broken eggs cannot be reused. Let &lt;math&gt;E(k, n)&lt;/math&gt; be the minimum number of egg drops that will always suffice.
:(a) Show that &lt;math&gt;E(1, n) = n&lt;/math&gt;.
:(b) Show that &lt;math&gt;E(k, n) = \Theta (n^{1/k})&lt;/math&gt;.
:(c) Find a recurrence for &lt;math&gt;E(k, n)&lt;/math&gt;. What is the running time of the dynamic program to find &lt;math&gt;E(k, n)&lt;/math&gt;?

===Graphing Problem===

:[[10.27]]. Consider a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. 
:Unfortunately, the city has bad neighborhoods, whose intersections we do not want to walk in. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is in a neighborhood to avoid.
:(a) Give an example of the contents of bad such that there is no path across the grid avoiding bad neighborhoods.
:(b) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find a path across the grid that avoids bad neighborhoods.
:(c) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find the shortest path across the grid that avoids bad neighborhoods. You may assume that all blocks are of equal length. For partial credit, give an &lt;math&gt;O(X^2Y^2)&lt;/math&gt; algorithm.
[[10.27|Solution]]


:10.28. Consider the same situation as the previous problem. We have a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is somewhere we want to avoid.
:If there were no bad neighborhoods to contend with, the shortest path across the grid would have length &lt;math&gt;(X - 1) + (Y - 1)&lt;/math&gt; blocks, and indeed there would be many such paths across the grid. Each path would consist of only rightward and downward moves.
:Give an algorithm that takes the array bad and returns the number of safe paths of length &lt;math&gt;X + Y - 2&lt;/math&gt;. For full credit, your algorithm must run in &lt;math&gt;O(XY)&lt;/math&gt;.


:[[10.29]]. You seek to create a stack out of &lt;math&gt;n&lt;/math&gt; boxes, where box &lt;math&gt;i&lt;/math&gt; has width &lt;math&gt;w_i&lt;/math&gt;, height &lt;math&gt;h_i&lt;/math&gt;, and depth &lt;math&gt;d_i&lt;/math&gt;. The boxes cannot be rotated, and can only be stacked on top of one another when each box in the stack is strictly larger than the box above it in width, height, and depth. Give an efficient algorithm to construct the tallest possible stack, where the height is the sum of the heights of each box in the stack.
[[10.29|Solution]]

===Design Problems===

:10.30


:[[10.31]]


:10.32


:[[10.33]]


:10.34


:[[10.35]]


:10.36


:[[10.37]]


:10.38


===Interview Problems===

:[[10.39]]


:10.40


:[[10.41]]


Back to [[Chapter List]]</text>
      <sha1>36qf0tslhrpqt4yt52ovzs3t3pl7bmx</sha1>
    </revision>
    <revision>
      <id>217</id>
      <parentid>216</parentid>
      <timestamp>2020-09-13T20:43:12Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Design Problems */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="22904">=Dynamic Programming=

===Elementary Recurrences===

:[[10.1]]. Up to &lt;math&gt;k&lt;/math&gt; steps in a single bound! A child is running up a staircase with &lt;math&gt;n&lt;/math&gt; steps and can hop between 1 and &lt;math&gt;k&lt;/math&gt; steps at a time. Design an algorithm to count how many possible ways the child can run up the stairs, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. What is the running time of your algorithm?
[[10.1|Solution]]


:10.2. Imagine you are a professional thief who plans to rob houses along a street of &lt;math&gt;n&lt;/math&gt; homes. You know the loot at house &lt;math&gt;i&lt;/math&gt; is worth &lt;math&gt;m_i&lt;/math&gt;, for &lt;math&gt;1 \le i \le n&lt;/math&gt;, but you cannot rob neighboring houses because their connected security systems will automatically contact the police if two adjacent houses are broken into. Give an efficient algorithm to determine the maximum amount of money you can steal without alerting the police.


:[[10.3]]. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible mixes (1s,2s,3s) of scoring add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are four possible solutions: (5, 0, 0), (2, 0, 1), (1, 2, 0), and (0, 1, 1).
[[10.3|Solution]]


:10.4. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible scoring sequences add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are thirteen possible sequences, including 1-2-1-1, 3-2, and 1-1-1-1-1.


:[[10.5]]. Given an &lt;math&gt;s * t&lt;/math&gt; grid filled with non-negative numbers, find a path from top left to bottom right that minimizes the sum of all numbers along its path. You can only move either down or right at any point in time.
::(a) Give a solution based on Dijkstra’s algorithm. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
::(b) Give a solution based on dynamic programming. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
[[10.5|Solution]]

===Edit Distance===

:10.6. Typists often make transposition errors exchanging neighboring characters, such as typing “setve” for “steve.” This requires two substitutions to fix under the conventional definition of edit distance.
:Incorporate a swap operation into our edit distance function, so that such neigh-
boring transposition errors can be fixed at the cost of one operation.


:[[10.7]]. Suppose you are given three strings of characters: &lt;math&gt;X&lt;/math&gt;, &lt;math&gt;Y&lt;/math&gt;, and &lt;math&gt;Z&lt;/math&gt;, where &lt;math&gt;|X| = n&lt;/math&gt;, &lt;math&gt;|Y| = m&lt;/math&gt;, and &lt;math&gt;|Z| = n + m&lt;/math&gt;. &lt;math&gt;Z&lt;/math&gt; is said to be a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; iff &lt;math&gt;Z&lt;/math&gt; can be formed by interleaving the characters from &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; in a way that maintains the left-to-right ordering of the characters from each string. 
:(a) Show that cchocohilaptes is a shuffle of chocolate and chips, but chocochilatspe is not.
:(b) Give an efficient dynamic programming algorithm that determines whether &lt;math&gt;Z&lt;/math&gt; is a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt;. (Hint: the values of the dynamic programming matrix you construct should be Boolean, not numeric.)
[[10.7|Solution]]


:10.8. The longest common substring (not subsequence) of two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; is the longest string that appears as a run of consecutive letters in both strings. For example, the longest common substring of photograph and tomography is ograph.
:(a) Let &lt;math&gt;n = |X|&lt;/math&gt; and &lt;math&gt;m = |Y|&lt;/math&gt;. Give a &lt;math&gt;\Theta (nm)&lt;/math&gt; dynamic programming algorithm for longest common substring based on the longest common subsequence/edit distance algorithm.
:(b) Give a simpler &lt;math&gt;\Theta (nm)&lt;/math&gt; algorithm that does not rely on dynamic programming.


:[[10.9]]. The ''longest common subsequence (LCS)'' of two sequences &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the longest sequence &lt;math&gt;L&lt;/math&gt; such that &lt;math&gt;L&lt;/math&gt; is a subsequence of both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;. The ''shortest common supersequence (SCS)'' of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the smallest sequence &lt;math&gt;L&lt;/math&gt; such that both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; are a subsequence of &lt;math&gt;L&lt;/math&gt;.
:(a) Give efficient algorithms to find the LCS and SCS of two given sequences.
:(b) Let &lt;math&gt;d(T, P)&lt;/math&gt; be the minimum edit distance between &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; when no substitutions are allowed (i.e., the only changes are character insertion and deletion). Prove that &lt;math&gt;d(T, P) = |SCS(T, P)| - |LCS(T, P)|&lt;/math&gt; where &lt;math&gt;|SCS(T, P)| (|LCS(T, P)|)&lt;/math&gt; is the size of the shortest SCS (longest LCS) of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;.
[[10.9|Solution]]


:10.10. Suppose you are given &lt;math&gt;n&lt;/math&gt; poker chips stacked in two stacks, where the edges of all chips can be seen. Each chip is one of three colors. A turn consists of choosing a color and removing all chips of that color from the tops of the stacks. The goal is to minimize the number of turns until the chips are gone. 
:For example, consider the stacks &lt;math&gt;(RRGG, GBBB)&lt;/math&gt;. Playing red, green, and then blue suffices to clear the stacks in three moves. Give an &lt;math&gt;O(n^2)&lt;/math&gt; dynamic programming algorithm to find the best strategy for a given pair of chip piles.

===Greedy Algorithms===

:[[10.11]]. Let &lt;math&gt;P_1, P_2, . . . , P_n&lt;/math&gt; be &lt;math&gt;n&lt;/math&gt; programs to be stored on a disk with capacity &lt;math&gt;D&lt;/math&gt; megabytes. Program &lt;math&gt;P_i&lt;/math&gt; requires &lt;math&gt;s_i&lt;/math&gt; megabytes of storage. We cannot store them all because &lt;math&gt;D &lt; \sum_{i=1}^n s_i &lt;/math&gt;
:(a) Does a greedy algorithm that selects programs in order of non-decreasing &lt;math&gt;s_i&lt;/math&gt; maximize the number of programs held on the disk? Prove or give a counter-example.
:(b) Does a greedy algorithm that selects programs in order of non-increasing &lt;math&gt;s_i&lt;/math&gt; use as much of the capacity of the disk as possible? Prove or give a counter-example.
[[10.11|Solution]]


:10.12. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We seek an algorithm to make change of &lt;math&gt;n&lt;/math&gt; units using the minimum number of this country’s coins.
:(a) The greedy algorithm repeatedly selects the biggest coin no bigger than the amount to be changed and repeats until it is zero. Show that the greedy algorithm does not always use the minimum number of coins in a country whose denominations are {1, 6, 10}.
:(b) Give an efficient algorithm that correctly determines the minimum number of coins needed to make change of &lt;math&gt;n&lt;/math&gt; units using denominations &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt;. Analyze its running time.


:[[10.13]]. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We want to count how many distinct ways &lt;math&gt;C(n)&lt;/math&gt; there are to make change of &lt;math&gt;n&lt;/math&gt; units. For example, in a country whose denominations are {1, 6, 10}, &lt;math&gt;C(5) = 1&lt;/math&gt;, &lt;math&gt;C(6)&lt;/math&gt; to &lt;math&gt;C(9) = 2&lt;/math&gt;, &lt;math&gt;C(10) = 3&lt;/math&gt;, and &lt;math&gt;C(12) = 4&lt;/math&gt;.
:(a) How many ways are there to make change of 20 units from {1, 6, 10}?
:(b) Give an efficient algorithm to compute &lt;math&gt;C(n)&lt;/math&gt;, and analyze its complexity. (Hint: think in terms of computing &lt;math&gt;C(n, d)&lt;/math&gt;, the number of ways to make change of &lt;math&gt;n&lt;/math&gt; units with highest denomination &lt;math&gt;d&lt;/math&gt;. Be careful to avoid overcounting.)
[[10.13|Solution]]


:10.14. In the single-processor scheduling problem, we are given a set of &lt;math&gt;n&lt;/math&gt; jobs &lt;math&gt;J&lt;/math&gt;. Each job &lt;math&gt;i&lt;/math&gt; has a processing time &lt;math&gt;t_i&lt;/math&gt;, and a deadline &lt;math&gt;d_i&lt;/math&gt;. A feasible schedule is a permutation of the jobs such that when the jobs are performed in that order, every job is finished before its deadline. The greedy algorithm for single-processor scheduling selects the job with the earliest deadline first.
:Show that if a feasible schedule exists, then the schedule produced by this greedy algorithm is feasible.

===Number Problems===

:[[10.15]]. You are given a rod of length &lt;math&gt;n&lt;/math&gt; inches and a table of prices obtainable for rod-pieces of size &lt;math&gt;n&lt;/math&gt; or smaller. Give an efficient algorithm to find the maximum value obtainable by cutting up the rod and selling the pieces. For example, if &lt;math&gt;n=8&lt;/math&gt; and the values of different pieces are:
&lt;center&gt;
\begin{array}{|C|rrrrrrrr} length &amp; 1 &amp; 2 &amp; 3 &amp; 4 &amp; 5 &amp; 6 &amp; 7 &amp; 8 \\
\hline
price &amp; 1 &amp; 5 &amp; 8 &amp; 9 &amp; 10 &amp; 17 &amp;17 &amp; 20 \\
\end{array}
&lt;/center&gt;
:then the maximum obtainable value is 22, by cutting into pieces of lengths 2 and 6.
[[10.15|Solution]]


:10.16. Your boss has written an arithmetic expression of n terms to compute your annual bonus, but permits you to parenthesize it however you wish. Give an efficient algorithm to design the parenthesization to maximize the value. For the expression:
&lt;center&gt;&lt;math&gt;6 + 2 * 0 - 4&lt;/math&gt;&lt;/center&gt;
:there exist parenthesizations with values ranging from −32 to 2.


:[[10.17]]. Given a positive integer &lt;math&gt;n&lt;/math&gt;, find an efficient algorithm to compute the smallest number of perfect squares (e.g. 1, 4, 9, 16, . . .) that sum to &lt;math&gt;n&lt;/math&gt;. What is the running time of your algorithm?
[[10.17|Solution]]


:10.18. Given an array &lt;math&gt;A&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find an efficient algorithm to compute the largest sum of a continuous run. For &lt;math&gt;A = [-3, 2, 7, -3, 4, -2, 0, 1]&lt;/math&gt;, the largest such sum is 10, from the second through fifth positions.


:[[10.19]]. Two drivers have to divide up &lt;math&gt;m&lt;/math&gt; suitcases between them, where the weight of the &lt;math&gt;ith&lt;/math&gt; suitcase is &lt;math&gt;w_i&lt;/math&gt;. Give an efficient algorithm to divide up the loads so the two drivers carry equal weight, if possible.
[[10.19|Solution]]


:10.20. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = {s_1, s_2, . . . , s_n}&lt;/math&gt;, and a given target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; that adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, within &lt;math&gt;S = {1, 2, 5, 9, 10}&lt;/math&gt; there is a subset that adds up to &lt;math&gt;T = 22&lt;/math&gt; but not &lt;math&gt;T = 23&lt;/math&gt;.
:Give a dynamic programming algorithm for knapsack that runs in &lt;math&gt;O(nT)&lt;/math&gt; time.


:[[10.21]]. The integer partition takes a set of positive integers &lt;math&gt;S = {s_1, . . . , s_n}&lt;/math&gt; and seeks a subset &lt;math&gt;I \subset S&lt;/math&gt; such that
&lt;center&gt;&lt;math&gt; \sum_{i \in I} s_i = \sum_{i \notin I} s_i&lt;/math&gt;&lt;/center&gt;
:Let &lt;math&gt; \sum_{i \in S} s_i = M &lt;/math&gt;. Give an &lt;math&gt;O(nM)&lt;/math&gt; dynamic programming algorithm to solve the integer partition problem.
[[10.21|Solution]]


:10.22. Assume that there are n numbers (some possibly negative) on a circle, and we wish to find the maximum contiguous sum along an arc of the circle. Give an efficient algorithm for solving this problem.


:[[10.23]]. A certain string processing language allows the programmer to break a string into two pieces. It costs &lt;math&gt;n&lt;/math&gt; units of time to break a string of &lt;math&gt;n&lt;/math&gt; characters into two pieces, since this involves copying the old string. A programmer wants to break a string into many pieces, and the order in which the breaks are made can affect the total amount of time used. For example, suppose we wish to break a 20-character string after characters 3, 8, and 10. If the breaks are made in left-to-right order, then the first break costs 20 units of time, the second break costs 17 units of time, and the third break costs 12 units of time, for a total of 49 units. If the breaks are made in right-to-left order, the first break costs 20 units of time, the second break costs 10 units of time, and the third break costs 8 units of time, for a total of only 38 units.
:Give a dynamic programming algorithm that takes a list of character positions after which to break and determines the cheapest break cost in &lt;math&gt;O(n^3)&lt;/math&gt; time.
[[10.23|Solution]]


:10.24. Consider the following data compression technique. We have a table of &lt;math&gt;m&lt;/math&gt; text strings, each at most &lt;math&gt;k&lt;/math&gt; in length. We want to encode a data string &lt;math&gt;D&lt;/math&gt; of length &lt;math&gt;n&lt;/math&gt; using as few text strings as possible. For example, if our table contains &lt;math&gt;(a,ba,abab,b)&lt;/math&gt; and the data string is &lt;math&gt;bababbaababa&lt;/math&gt;, the best way to encode it is &lt;math&gt;(b,abab,ba,abab,a)-a&lt;/math&gt; total of five code words. Give an &lt;math&gt;O(nmk)&lt;/math&gt; algorithm to find the length of the best encoding. You may assume that every string has at least one encoding in terms of the table.


:[[10.25]]. The traditional world chess championship is a match of 24 games. The current champion retains the title in case the match is a tie. Each game ends in a win, loss, or draw (tie) where wins count as 1, losses as 0, and draws as &lt;math&gt;1/2&lt;/math&gt;. The players take turns playing white and black. White plays first and so has an advantage. The champion plays white in the first game. The champ has probabilities &lt;math&gt;w_w&lt;/math&gt;, &lt;math&gt;w_d&lt;/math&gt;, and &lt;math&gt;w_l&lt;/math&gt; of winning, drawing, and losing playing white, and has probabilities &lt;math&gt;b_w&lt;/math&gt;, &lt;math&gt;b_d&lt;/math&gt;, and &lt;math&gt;b_l&lt;/math&gt; of winning, drawing, and losing playing black.
:(a) Write a recurrence for the probability that the champion retains the title. Assume that there are &lt;math&gt;g&lt;/math&gt; games left to play in the match and that the champion needs to get &lt;math&gt;i&lt;/math&gt; points (which may be a multiple of &lt;math&gt;1/2&lt;/math&gt;).
:(b) Based on your recurrence, give a dynamic programming algorithm to calculate the champion’s probability of retaining the title.
:(c) Analyze its running time for an &lt;math&gt;n&lt;/math&gt; game match.
[[10.125|Solution]]


:10.26. Eggs break when dropped from great enough height. Specifically, there must be a floor &lt;math&gt;f&lt;/math&gt; in any sufficiently tall building such that an egg dropped from the &lt;math&gt;f&lt;/math&gt;th floor breaks, but one dropped from the &lt;math&gt;(f - 1)&lt;/math&gt;st floor will not. If the egg always breaks, then &lt;math&gt;f = 1&lt;/math&gt;. If the egg never breaks, then &lt;math&gt;f = n + 1&lt;/math&gt;. 
:You seek to find the critical floor &lt;math&gt;f&lt;/math&gt; using an &lt;math&gt;n-floor&lt;/math&gt; building. The only operation you can perform is to drop an egg off some floor and see what happens. You start out with &lt;math&gt;k&lt;/math&gt; eggs, and seek to make as few drops as possible. Broken eggs cannot be reused. Let &lt;math&gt;E(k, n)&lt;/math&gt; be the minimum number of egg drops that will always suffice.
:(a) Show that &lt;math&gt;E(1, n) = n&lt;/math&gt;.
:(b) Show that &lt;math&gt;E(k, n) = \Theta (n^{1/k})&lt;/math&gt;.
:(c) Find a recurrence for &lt;math&gt;E(k, n)&lt;/math&gt;. What is the running time of the dynamic program to find &lt;math&gt;E(k, n)&lt;/math&gt;?

===Graphing Problem===

:[[10.27]]. Consider a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. 
:Unfortunately, the city has bad neighborhoods, whose intersections we do not want to walk in. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is in a neighborhood to avoid.
:(a) Give an example of the contents of bad such that there is no path across the grid avoiding bad neighborhoods.
:(b) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find a path across the grid that avoids bad neighborhoods.
:(c) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find the shortest path across the grid that avoids bad neighborhoods. You may assume that all blocks are of equal length. For partial credit, give an &lt;math&gt;O(X^2Y^2)&lt;/math&gt; algorithm.
[[10.27|Solution]]


:10.28. Consider the same situation as the previous problem. We have a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is somewhere we want to avoid.
:If there were no bad neighborhoods to contend with, the shortest path across the grid would have length &lt;math&gt;(X - 1) + (Y - 1)&lt;/math&gt; blocks, and indeed there would be many such paths across the grid. Each path would consist of only rightward and downward moves.
:Give an algorithm that takes the array bad and returns the number of safe paths of length &lt;math&gt;X + Y - 2&lt;/math&gt;. For full credit, your algorithm must run in &lt;math&gt;O(XY)&lt;/math&gt;.


:[[10.29]]. You seek to create a stack out of &lt;math&gt;n&lt;/math&gt; boxes, where box &lt;math&gt;i&lt;/math&gt; has width &lt;math&gt;w_i&lt;/math&gt;, height &lt;math&gt;h_i&lt;/math&gt;, and depth &lt;math&gt;d_i&lt;/math&gt;. The boxes cannot be rotated, and can only be stacked on top of one another when each box in the stack is strictly larger than the box above it in width, height, and depth. Give an efficient algorithm to construct the tallest possible stack, where the height is the sum of the heights of each box in the stack.
[[10.29|Solution]]

===Design Problems===

:10.30. Consider the problem of storing &lt;math&gt;n&lt;/math&gt; books on shelves in a library. The order of the books is fixed by the cataloging system and so cannot be rearranged. Therefore, we can speak of a book &lt;math&gt;b_i&lt;/math&gt;, where &lt;math&gt;1 \leq i \leq n&lt;/math&gt;, that has a thickness &lt;math&gt;t_i&lt;/math&gt; and height &lt;math&gt;h_i&lt;/math&gt;. The length of each bookshelf at this library is &lt;math&gt;L&lt;/math&gt;.
:Suppose all the books have the same height &lt;math&gt;h&lt;/math&gt; (i.e., &lt;math&gt;h = h_i&lt;/math&gt; for all &lt;math&gt;i&lt;/math&gt;) and the shelves are all separated by a distance greater than &lt;math&gt;h&lt;/math&gt;, so any book fits on any shelf. The greedy algorithm would fill the first shelf with as many books as we can until we get the smallest &lt;math&gt;i&lt;/math&gt; such that &lt;math&gt;b_i&lt;/math&gt; does not fit, and then repeat with subsequent shelves. Show that the greedy algorithm always finds the book placement that uses the minimum number of shelves, and analyze its time complexity.


:[[10.31]]. This is a generalization of the previous problem. Now consider the case where the height of the books is not constant, but we have the freedom to adjust the height of each shelf to that of the tallest book on the shelf. Here the cost of a particular layout is the sum of the heights of the largest book on each shelf.
:#Give an example to show that the greedy algorithm of stuffing each shelf as full as possible does not always give the minimum overall height.
:#Give an algorithm for this problem, and analyze its time complexity. (Hint: use dynamic programming.)
[[10.31|Solution]]


:10.32. Consider a linear keyboard of lowercase letters and numbers, where the left-most 26 keys are the letters A–Z in order, followed by the digits 0–9 in order, followed by the 30 punctuation characters in a prescribed order, and ended on a blank. Assume you start with your left index finger on the “A” and your right index finger on the blank.
:Give a dynamic programming algorithm that finds the most efficient way to type a given text of length &lt;math&gt;n&lt;/math&gt;, in terms of minimizing total movement of the fingers involved. For the text &lt;math&gt;ABABABAB . . . ABAB&lt;/math&gt;, this would involve shifting both fingers all the way to the left side of the keyboard. Analyze the complexity of your algorithm as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;, the number of keys on the keyboard.


:[[10.33]]. You have come back from the future with an array &lt;math&gt;G&lt;/math&gt;, where &lt;math&gt;G[i]&lt;/math&gt; tells you the price of Google stock &lt;math&gt;i&lt;/math&gt; days from now, for &lt;math&gt;1 \leq i \leq n&lt;/math&gt;. You seek to use this information to maximize your profit, but are only permitted to complete at most one transaction (i.e. either buy one or sell one share of the stock) per day. Design an efficient algorithm to construct the buy–sell sequence to maximize your profit. Note that you cannot sell a share unless you currently own one.
[[10.33|Solution]]


:10.34. You are given a string of &lt;math&gt;n&lt;/math&gt; characters &lt;math&gt;S = s_1 . . . s_n&lt;/math&gt;, which you believe to be a compressed text document in which all spaces have been removed, like '''itwasthebestoftimes'''.
:(a) You seek to reconstruct the document using a dictionary, which is available in the form of a Boolean function &lt;math&gt;dict(w)&lt;/math&gt;, where &lt;math&gt;dict(w)&lt;/math&gt; is true iff string &lt;math&gt;w&lt;/math&gt; is
a valid word in the language. Give an &lt;math&gt;O(n^2)&lt;/math&gt; algorithm to determine whether string &lt;math&gt;S&lt;/math&gt; can be reconstituted as a sequence of valid words, assuming calls to &lt;math&gt;dict(w)&lt;/math&gt; take unit time.
:(b) Now assume you are given the dictionary as a set of &lt;math&gt;m&lt;/math&gt; words each of length at most l. Give an efficient algorithm to determine whether string &lt;math&gt;S&lt;/math&gt; can be reconstituted as a sequence of valid words, and its running time.


:[[10.35]]. Consider the following two-player game, where you seek to get the biggest score. You start with an n-digit integer &lt;math&gt;N&lt;/math&gt;. With each move, you get to take either the first digit or the last digit from what is left of &lt;math&gt;N&lt;/math&gt;, and add that to your score, with your opponent then doing the same thing to the now smaller number. You continue taking turns removing digits until none are left. Give an efficient algorithm that finds the best possible score that the first player can get for a given digit string &lt;math&gt;N&lt;/math&gt;, assuming the second player is as smart as can be.
[[10.35|Solution]]


:10.36. Given an array of &lt;math&gt;n&lt;/math&gt; real numbers, consider the problem of finding the maximum sum in any contiguous subarray of the input. For example, in the array
&lt;center&gt;&lt;math&gt;[31, -41, 59, 26, -53, 58, 97, -93, -23, 84]&lt;/math&gt;&lt;/center&gt;
:the maximum is achieved by summing the third through seventh elements, where 59 + 26 + (−53) + 58 + 97 = 187. When all numbers are positive, the entire array is the answer, while when all numbers are negative, the empty array maximizes the total at 0.
#Give a simple and clear &lt;math&gt; \Theta (n^2)&lt;/math&gt;-time algorithm to find the maximum contiguous subarray.
#Now give a &lt;math&gt;\Theta (n)&lt;/math&gt;-time dynamic programming algorithm for this problem. To get partial credit, you may instead give a correct &lt;math&gt;O(n log n)&lt;/math&gt; divide-and-conquer algorithm.


:[[10.37]]


:10.38. Let α and β be constants. Assume that it costs α to go left in a binary search tree, and β to go right. Devise an algorithm that builds a tree with optimal expected query cost, given keys &lt;math&gt;k_1, . . . , k_n&lt;/math&gt; and the probabilities that each will be searched &lt;math&gt;p_1, . . . , p_n&lt;/math&gt;.

===Interview Problems===

:[[10.39]]


:10.40


:[[10.41]]


Back to [[Chapter List]]</text>
      <sha1>a0tjf853tob4khdqzgk2uye9loo0kg6</sha1>
    </revision>
    <revision>
      <id>218</id>
      <parentid>217</parentid>
      <timestamp>2020-09-13T20:43:50Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Design Problems */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="22904">=Dynamic Programming=

===Elementary Recurrences===

:[[10.1]]. Up to &lt;math&gt;k&lt;/math&gt; steps in a single bound! A child is running up a staircase with &lt;math&gt;n&lt;/math&gt; steps and can hop between 1 and &lt;math&gt;k&lt;/math&gt; steps at a time. Design an algorithm to count how many possible ways the child can run up the stairs, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. What is the running time of your algorithm?
[[10.1|Solution]]


:10.2. Imagine you are a professional thief who plans to rob houses along a street of &lt;math&gt;n&lt;/math&gt; homes. You know the loot at house &lt;math&gt;i&lt;/math&gt; is worth &lt;math&gt;m_i&lt;/math&gt;, for &lt;math&gt;1 \le i \le n&lt;/math&gt;, but you cannot rob neighboring houses because their connected security systems will automatically contact the police if two adjacent houses are broken into. Give an efficient algorithm to determine the maximum amount of money you can steal without alerting the police.


:[[10.3]]. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible mixes (1s,2s,3s) of scoring add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are four possible solutions: (5, 0, 0), (2, 0, 1), (1, 2, 0), and (0, 1, 1).
[[10.3|Solution]]


:10.4. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible scoring sequences add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are thirteen possible sequences, including 1-2-1-1, 3-2, and 1-1-1-1-1.


:[[10.5]]. Given an &lt;math&gt;s * t&lt;/math&gt; grid filled with non-negative numbers, find a path from top left to bottom right that minimizes the sum of all numbers along its path. You can only move either down or right at any point in time.
::(a) Give a solution based on Dijkstra’s algorithm. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
::(b) Give a solution based on dynamic programming. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
[[10.5|Solution]]

===Edit Distance===

:10.6. Typists often make transposition errors exchanging neighboring characters, such as typing “setve” for “steve.” This requires two substitutions to fix under the conventional definition of edit distance.
:Incorporate a swap operation into our edit distance function, so that such neigh-
boring transposition errors can be fixed at the cost of one operation.


:[[10.7]]. Suppose you are given three strings of characters: &lt;math&gt;X&lt;/math&gt;, &lt;math&gt;Y&lt;/math&gt;, and &lt;math&gt;Z&lt;/math&gt;, where &lt;math&gt;|X| = n&lt;/math&gt;, &lt;math&gt;|Y| = m&lt;/math&gt;, and &lt;math&gt;|Z| = n + m&lt;/math&gt;. &lt;math&gt;Z&lt;/math&gt; is said to be a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; iff &lt;math&gt;Z&lt;/math&gt; can be formed by interleaving the characters from &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; in a way that maintains the left-to-right ordering of the characters from each string. 
:(a) Show that cchocohilaptes is a shuffle of chocolate and chips, but chocochilatspe is not.
:(b) Give an efficient dynamic programming algorithm that determines whether &lt;math&gt;Z&lt;/math&gt; is a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt;. (Hint: the values of the dynamic programming matrix you construct should be Boolean, not numeric.)
[[10.7|Solution]]


:10.8. The longest common substring (not subsequence) of two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; is the longest string that appears as a run of consecutive letters in both strings. For example, the longest common substring of photograph and tomography is ograph.
:(a) Let &lt;math&gt;n = |X|&lt;/math&gt; and &lt;math&gt;m = |Y|&lt;/math&gt;. Give a &lt;math&gt;\Theta (nm)&lt;/math&gt; dynamic programming algorithm for longest common substring based on the longest common subsequence/edit distance algorithm.
:(b) Give a simpler &lt;math&gt;\Theta (nm)&lt;/math&gt; algorithm that does not rely on dynamic programming.


:[[10.9]]. The ''longest common subsequence (LCS)'' of two sequences &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the longest sequence &lt;math&gt;L&lt;/math&gt; such that &lt;math&gt;L&lt;/math&gt; is a subsequence of both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;. The ''shortest common supersequence (SCS)'' of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the smallest sequence &lt;math&gt;L&lt;/math&gt; such that both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; are a subsequence of &lt;math&gt;L&lt;/math&gt;.
:(a) Give efficient algorithms to find the LCS and SCS of two given sequences.
:(b) Let &lt;math&gt;d(T, P)&lt;/math&gt; be the minimum edit distance between &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; when no substitutions are allowed (i.e., the only changes are character insertion and deletion). Prove that &lt;math&gt;d(T, P) = |SCS(T, P)| - |LCS(T, P)|&lt;/math&gt; where &lt;math&gt;|SCS(T, P)| (|LCS(T, P)|)&lt;/math&gt; is the size of the shortest SCS (longest LCS) of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;.
[[10.9|Solution]]


:10.10. Suppose you are given &lt;math&gt;n&lt;/math&gt; poker chips stacked in two stacks, where the edges of all chips can be seen. Each chip is one of three colors. A turn consists of choosing a color and removing all chips of that color from the tops of the stacks. The goal is to minimize the number of turns until the chips are gone. 
:For example, consider the stacks &lt;math&gt;(RRGG, GBBB)&lt;/math&gt;. Playing red, green, and then blue suffices to clear the stacks in three moves. Give an &lt;math&gt;O(n^2)&lt;/math&gt; dynamic programming algorithm to find the best strategy for a given pair of chip piles.

===Greedy Algorithms===

:[[10.11]]. Let &lt;math&gt;P_1, P_2, . . . , P_n&lt;/math&gt; be &lt;math&gt;n&lt;/math&gt; programs to be stored on a disk with capacity &lt;math&gt;D&lt;/math&gt; megabytes. Program &lt;math&gt;P_i&lt;/math&gt; requires &lt;math&gt;s_i&lt;/math&gt; megabytes of storage. We cannot store them all because &lt;math&gt;D &lt; \sum_{i=1}^n s_i &lt;/math&gt;
:(a) Does a greedy algorithm that selects programs in order of non-decreasing &lt;math&gt;s_i&lt;/math&gt; maximize the number of programs held on the disk? Prove or give a counter-example.
:(b) Does a greedy algorithm that selects programs in order of non-increasing &lt;math&gt;s_i&lt;/math&gt; use as much of the capacity of the disk as possible? Prove or give a counter-example.
[[10.11|Solution]]


:10.12. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We seek an algorithm to make change of &lt;math&gt;n&lt;/math&gt; units using the minimum number of this country’s coins.
:(a) The greedy algorithm repeatedly selects the biggest coin no bigger than the amount to be changed and repeats until it is zero. Show that the greedy algorithm does not always use the minimum number of coins in a country whose denominations are {1, 6, 10}.
:(b) Give an efficient algorithm that correctly determines the minimum number of coins needed to make change of &lt;math&gt;n&lt;/math&gt; units using denominations &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt;. Analyze its running time.


:[[10.13]]. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We want to count how many distinct ways &lt;math&gt;C(n)&lt;/math&gt; there are to make change of &lt;math&gt;n&lt;/math&gt; units. For example, in a country whose denominations are {1, 6, 10}, &lt;math&gt;C(5) = 1&lt;/math&gt;, &lt;math&gt;C(6)&lt;/math&gt; to &lt;math&gt;C(9) = 2&lt;/math&gt;, &lt;math&gt;C(10) = 3&lt;/math&gt;, and &lt;math&gt;C(12) = 4&lt;/math&gt;.
:(a) How many ways are there to make change of 20 units from {1, 6, 10}?
:(b) Give an efficient algorithm to compute &lt;math&gt;C(n)&lt;/math&gt;, and analyze its complexity. (Hint: think in terms of computing &lt;math&gt;C(n, d)&lt;/math&gt;, the number of ways to make change of &lt;math&gt;n&lt;/math&gt; units with highest denomination &lt;math&gt;d&lt;/math&gt;. Be careful to avoid overcounting.)
[[10.13|Solution]]


:10.14. In the single-processor scheduling problem, we are given a set of &lt;math&gt;n&lt;/math&gt; jobs &lt;math&gt;J&lt;/math&gt;. Each job &lt;math&gt;i&lt;/math&gt; has a processing time &lt;math&gt;t_i&lt;/math&gt;, and a deadline &lt;math&gt;d_i&lt;/math&gt;. A feasible schedule is a permutation of the jobs such that when the jobs are performed in that order, every job is finished before its deadline. The greedy algorithm for single-processor scheduling selects the job with the earliest deadline first.
:Show that if a feasible schedule exists, then the schedule produced by this greedy algorithm is feasible.

===Number Problems===

:[[10.15]]. You are given a rod of length &lt;math&gt;n&lt;/math&gt; inches and a table of prices obtainable for rod-pieces of size &lt;math&gt;n&lt;/math&gt; or smaller. Give an efficient algorithm to find the maximum value obtainable by cutting up the rod and selling the pieces. For example, if &lt;math&gt;n=8&lt;/math&gt; and the values of different pieces are:
&lt;center&gt;
\begin{array}{|C|rrrrrrrr} length &amp; 1 &amp; 2 &amp; 3 &amp; 4 &amp; 5 &amp; 6 &amp; 7 &amp; 8 \\
\hline
price &amp; 1 &amp; 5 &amp; 8 &amp; 9 &amp; 10 &amp; 17 &amp;17 &amp; 20 \\
\end{array}
&lt;/center&gt;
:then the maximum obtainable value is 22, by cutting into pieces of lengths 2 and 6.
[[10.15|Solution]]


:10.16. Your boss has written an arithmetic expression of n terms to compute your annual bonus, but permits you to parenthesize it however you wish. Give an efficient algorithm to design the parenthesization to maximize the value. For the expression:
&lt;center&gt;&lt;math&gt;6 + 2 * 0 - 4&lt;/math&gt;&lt;/center&gt;
:there exist parenthesizations with values ranging from −32 to 2.


:[[10.17]]. Given a positive integer &lt;math&gt;n&lt;/math&gt;, find an efficient algorithm to compute the smallest number of perfect squares (e.g. 1, 4, 9, 16, . . .) that sum to &lt;math&gt;n&lt;/math&gt;. What is the running time of your algorithm?
[[10.17|Solution]]


:10.18. Given an array &lt;math&gt;A&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find an efficient algorithm to compute the largest sum of a continuous run. For &lt;math&gt;A = [-3, 2, 7, -3, 4, -2, 0, 1]&lt;/math&gt;, the largest such sum is 10, from the second through fifth positions.


:[[10.19]]. Two drivers have to divide up &lt;math&gt;m&lt;/math&gt; suitcases between them, where the weight of the &lt;math&gt;ith&lt;/math&gt; suitcase is &lt;math&gt;w_i&lt;/math&gt;. Give an efficient algorithm to divide up the loads so the two drivers carry equal weight, if possible.
[[10.19|Solution]]


:10.20. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = {s_1, s_2, . . . , s_n}&lt;/math&gt;, and a given target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; that adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, within &lt;math&gt;S = {1, 2, 5, 9, 10}&lt;/math&gt; there is a subset that adds up to &lt;math&gt;T = 22&lt;/math&gt; but not &lt;math&gt;T = 23&lt;/math&gt;.
:Give a dynamic programming algorithm for knapsack that runs in &lt;math&gt;O(nT)&lt;/math&gt; time.


:[[10.21]]. The integer partition takes a set of positive integers &lt;math&gt;S = {s_1, . . . , s_n}&lt;/math&gt; and seeks a subset &lt;math&gt;I \subset S&lt;/math&gt; such that
&lt;center&gt;&lt;math&gt; \sum_{i \in I} s_i = \sum_{i \notin I} s_i&lt;/math&gt;&lt;/center&gt;
:Let &lt;math&gt; \sum_{i \in S} s_i = M &lt;/math&gt;. Give an &lt;math&gt;O(nM)&lt;/math&gt; dynamic programming algorithm to solve the integer partition problem.
[[10.21|Solution]]


:10.22. Assume that there are n numbers (some possibly negative) on a circle, and we wish to find the maximum contiguous sum along an arc of the circle. Give an efficient algorithm for solving this problem.


:[[10.23]]. A certain string processing language allows the programmer to break a string into two pieces. It costs &lt;math&gt;n&lt;/math&gt; units of time to break a string of &lt;math&gt;n&lt;/math&gt; characters into two pieces, since this involves copying the old string. A programmer wants to break a string into many pieces, and the order in which the breaks are made can affect the total amount of time used. For example, suppose we wish to break a 20-character string after characters 3, 8, and 10. If the breaks are made in left-to-right order, then the first break costs 20 units of time, the second break costs 17 units of time, and the third break costs 12 units of time, for a total of 49 units. If the breaks are made in right-to-left order, the first break costs 20 units of time, the second break costs 10 units of time, and the third break costs 8 units of time, for a total of only 38 units.
:Give a dynamic programming algorithm that takes a list of character positions after which to break and determines the cheapest break cost in &lt;math&gt;O(n^3)&lt;/math&gt; time.
[[10.23|Solution]]


:10.24. Consider the following data compression technique. We have a table of &lt;math&gt;m&lt;/math&gt; text strings, each at most &lt;math&gt;k&lt;/math&gt; in length. We want to encode a data string &lt;math&gt;D&lt;/math&gt; of length &lt;math&gt;n&lt;/math&gt; using as few text strings as possible. For example, if our table contains &lt;math&gt;(a,ba,abab,b)&lt;/math&gt; and the data string is &lt;math&gt;bababbaababa&lt;/math&gt;, the best way to encode it is &lt;math&gt;(b,abab,ba,abab,a)-a&lt;/math&gt; total of five code words. Give an &lt;math&gt;O(nmk)&lt;/math&gt; algorithm to find the length of the best encoding. You may assume that every string has at least one encoding in terms of the table.


:[[10.25]]. The traditional world chess championship is a match of 24 games. The current champion retains the title in case the match is a tie. Each game ends in a win, loss, or draw (tie) where wins count as 1, losses as 0, and draws as &lt;math&gt;1/2&lt;/math&gt;. The players take turns playing white and black. White plays first and so has an advantage. The champion plays white in the first game. The champ has probabilities &lt;math&gt;w_w&lt;/math&gt;, &lt;math&gt;w_d&lt;/math&gt;, and &lt;math&gt;w_l&lt;/math&gt; of winning, drawing, and losing playing white, and has probabilities &lt;math&gt;b_w&lt;/math&gt;, &lt;math&gt;b_d&lt;/math&gt;, and &lt;math&gt;b_l&lt;/math&gt; of winning, drawing, and losing playing black.
:(a) Write a recurrence for the probability that the champion retains the title. Assume that there are &lt;math&gt;g&lt;/math&gt; games left to play in the match and that the champion needs to get &lt;math&gt;i&lt;/math&gt; points (which may be a multiple of &lt;math&gt;1/2&lt;/math&gt;).
:(b) Based on your recurrence, give a dynamic programming algorithm to calculate the champion’s probability of retaining the title.
:(c) Analyze its running time for an &lt;math&gt;n&lt;/math&gt; game match.
[[10.125|Solution]]


:10.26. Eggs break when dropped from great enough height. Specifically, there must be a floor &lt;math&gt;f&lt;/math&gt; in any sufficiently tall building such that an egg dropped from the &lt;math&gt;f&lt;/math&gt;th floor breaks, but one dropped from the &lt;math&gt;(f - 1)&lt;/math&gt;st floor will not. If the egg always breaks, then &lt;math&gt;f = 1&lt;/math&gt;. If the egg never breaks, then &lt;math&gt;f = n + 1&lt;/math&gt;. 
:You seek to find the critical floor &lt;math&gt;f&lt;/math&gt; using an &lt;math&gt;n-floor&lt;/math&gt; building. The only operation you can perform is to drop an egg off some floor and see what happens. You start out with &lt;math&gt;k&lt;/math&gt; eggs, and seek to make as few drops as possible. Broken eggs cannot be reused. Let &lt;math&gt;E(k, n)&lt;/math&gt; be the minimum number of egg drops that will always suffice.
:(a) Show that &lt;math&gt;E(1, n) = n&lt;/math&gt;.
:(b) Show that &lt;math&gt;E(k, n) = \Theta (n^{1/k})&lt;/math&gt;.
:(c) Find a recurrence for &lt;math&gt;E(k, n)&lt;/math&gt;. What is the running time of the dynamic program to find &lt;math&gt;E(k, n)&lt;/math&gt;?

===Graphing Problem===

:[[10.27]]. Consider a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. 
:Unfortunately, the city has bad neighborhoods, whose intersections we do not want to walk in. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is in a neighborhood to avoid.
:(a) Give an example of the contents of bad such that there is no path across the grid avoiding bad neighborhoods.
:(b) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find a path across the grid that avoids bad neighborhoods.
:(c) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find the shortest path across the grid that avoids bad neighborhoods. You may assume that all blocks are of equal length. For partial credit, give an &lt;math&gt;O(X^2Y^2)&lt;/math&gt; algorithm.
[[10.27|Solution]]


:10.28. Consider the same situation as the previous problem. We have a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is somewhere we want to avoid.
:If there were no bad neighborhoods to contend with, the shortest path across the grid would have length &lt;math&gt;(X - 1) + (Y - 1)&lt;/math&gt; blocks, and indeed there would be many such paths across the grid. Each path would consist of only rightward and downward moves.
:Give an algorithm that takes the array bad and returns the number of safe paths of length &lt;math&gt;X + Y - 2&lt;/math&gt;. For full credit, your algorithm must run in &lt;math&gt;O(XY)&lt;/math&gt;.


:[[10.29]]. You seek to create a stack out of &lt;math&gt;n&lt;/math&gt; boxes, where box &lt;math&gt;i&lt;/math&gt; has width &lt;math&gt;w_i&lt;/math&gt;, height &lt;math&gt;h_i&lt;/math&gt;, and depth &lt;math&gt;d_i&lt;/math&gt;. The boxes cannot be rotated, and can only be stacked on top of one another when each box in the stack is strictly larger than the box above it in width, height, and depth. Give an efficient algorithm to construct the tallest possible stack, where the height is the sum of the heights of each box in the stack.
[[10.29|Solution]]

===Design Problems===

:10.30. Consider the problem of storing &lt;math&gt;n&lt;/math&gt; books on shelves in a library. The order of the books is fixed by the cataloging system and so cannot be rearranged. Therefore, we can speak of a book &lt;math&gt;b_i&lt;/math&gt;, where &lt;math&gt;1 \leq i \leq n&lt;/math&gt;, that has a thickness &lt;math&gt;t_i&lt;/math&gt; and height &lt;math&gt;h_i&lt;/math&gt;. The length of each bookshelf at this library is &lt;math&gt;L&lt;/math&gt;.
:Suppose all the books have the same height &lt;math&gt;h&lt;/math&gt; (i.e., &lt;math&gt;h = h_i&lt;/math&gt; for all &lt;math&gt;i&lt;/math&gt;) and the shelves are all separated by a distance greater than &lt;math&gt;h&lt;/math&gt;, so any book fits on any shelf. The greedy algorithm would fill the first shelf with as many books as we can until we get the smallest &lt;math&gt;i&lt;/math&gt; such that &lt;math&gt;b_i&lt;/math&gt; does not fit, and then repeat with subsequent shelves. Show that the greedy algorithm always finds the book placement that uses the minimum number of shelves, and analyze its time complexity.


:[[10.31]]. This is a generalization of the previous problem. Now consider the case where the height of the books is not constant, but we have the freedom to adjust the height of each shelf to that of the tallest book on the shelf. Here the cost of a particular layout is the sum of the heights of the largest book on each shelf.
:#Give an example to show that the greedy algorithm of stuffing each shelf as full as possible does not always give the minimum overall height.
:#Give an algorithm for this problem, and analyze its time complexity. (Hint: use dynamic programming.)
[[10.31|Solution]]


:10.32. Consider a linear keyboard of lowercase letters and numbers, where the left-most 26 keys are the letters A–Z in order, followed by the digits 0–9 in order, followed by the 30 punctuation characters in a prescribed order, and ended on a blank. Assume you start with your left index finger on the “A” and your right index finger on the blank.
:Give a dynamic programming algorithm that finds the most efficient way to type a given text of length &lt;math&gt;n&lt;/math&gt;, in terms of minimizing total movement of the fingers involved. For the text &lt;math&gt;ABABABAB . . . ABAB&lt;/math&gt;, this would involve shifting both fingers all the way to the left side of the keyboard. Analyze the complexity of your algorithm as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;, the number of keys on the keyboard.


:[[10.33]]. You have come back from the future with an array &lt;math&gt;G&lt;/math&gt;, where &lt;math&gt;G[i]&lt;/math&gt; tells you the price of Google stock &lt;math&gt;i&lt;/math&gt; days from now, for &lt;math&gt;1 \leq i \leq n&lt;/math&gt;. You seek to use this information to maximize your profit, but are only permitted to complete at most one transaction (i.e. either buy one or sell one share of the stock) per day. Design an efficient algorithm to construct the buy–sell sequence to maximize your profit. Note that you cannot sell a share unless you currently own one.
[[10.33|Solution]]


:10.34. You are given a string of &lt;math&gt;n&lt;/math&gt; characters &lt;math&gt;S = s_1 . . . s_n&lt;/math&gt;, which you believe to be a compressed text document in which all spaces have been removed, like '''itwasthebestoftimes'''.
:(a) You seek to reconstruct the document using a dictionary, which is available in the form of a Boolean function &lt;math&gt;dict(w)&lt;/math&gt;, where &lt;math&gt;dict(w)&lt;/math&gt; is true iff string &lt;math&gt;w&lt;/math&gt; is a valid word in the language. Give an &lt;math&gt;O(n^2)&lt;/math&gt; algorithm to determine whether string &lt;math&gt;S&lt;/math&gt; can be reconstituted as a sequence of valid words, assuming calls to &lt;math&gt;dict(w &lt;/math&gt; take unit time.
:(b) Now assume you are given the dictionary as a set of &lt;math&gt;m&lt;/math&gt; words each of length at most l. Give an efficient algorithm to determine whether string &lt;math&gt;S&lt;/math&gt; can be reconstituted as a sequence of valid words, and its running time.


:[[10.35]]. Consider the following two-player game, where you seek to get the biggest score. You start with an n-digit integer &lt;math&gt;N&lt;/math&gt;. With each move, you get to take either the first digit or the last digit from what is left of &lt;math&gt;N&lt;/math&gt;, and add that to your score, with your opponent then doing the same thing to the now smaller number. You continue taking turns removing digits until none are left. Give an efficient algorithm that finds the best possible score that the first player can get for a given digit string &lt;math&gt;N&lt;/math&gt;, assuming the second player is as smart as can be.
[[10.35|Solution]]


:10.36. Given an array of &lt;math&gt;n&lt;/math&gt; real numbers, consider the problem of finding the maximum sum in any contiguous subarray of the input. For example, in the array
&lt;center&gt;&lt;math&gt;[31, -41, 59, 26, -53, 58, 97, -93, -23, 84]&lt;/math&gt;&lt;/center&gt;
:the maximum is achieved by summing the third through seventh elements, where 59 + 26 + (−53) + 58 + 97 = 187. When all numbers are positive, the entire array is the answer, while when all numbers are negative, the empty array maximizes the total at 0.
#Give a simple and clear &lt;math&gt; \Theta (n^2)&lt;/math&gt;-time algorithm to find the maximum contiguous subarray.
#Now give a &lt;math&gt;\Theta (n)&lt;/math&gt;-time dynamic programming algorithm for this problem. To get partial credit, you may instead give a correct &lt;math&gt;O(n log n)&lt;/math&gt; divide-and-conquer algorithm.


:[[10.37]]


:10.38. Let α and β be constants. Assume that it costs α to go left in a binary search tree, and β to go right. Devise an algorithm that builds a tree with optimal expected query cost, given keys &lt;math&gt;k_1, . . . , k_n&lt;/math&gt; and the probabilities that each will be searched &lt;math&gt;p_1, . . . , p_n&lt;/math&gt;.

===Interview Problems===

:[[10.39]]


:10.40


:[[10.41]]


Back to [[Chapter List]]</text>
      <sha1>iaatnq9seiu16gpn41byy2zukcm94ve</sha1>
    </revision>
    <revision>
      <id>219</id>
      <parentid>218</parentid>
      <timestamp>2020-09-13T20:44:41Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Design Problems */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="22904">=Dynamic Programming=

===Elementary Recurrences===

:[[10.1]]. Up to &lt;math&gt;k&lt;/math&gt; steps in a single bound! A child is running up a staircase with &lt;math&gt;n&lt;/math&gt; steps and can hop between 1 and &lt;math&gt;k&lt;/math&gt; steps at a time. Design an algorithm to count how many possible ways the child can run up the stairs, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. What is the running time of your algorithm?
[[10.1|Solution]]


:10.2. Imagine you are a professional thief who plans to rob houses along a street of &lt;math&gt;n&lt;/math&gt; homes. You know the loot at house &lt;math&gt;i&lt;/math&gt; is worth &lt;math&gt;m_i&lt;/math&gt;, for &lt;math&gt;1 \le i \le n&lt;/math&gt;, but you cannot rob neighboring houses because their connected security systems will automatically contact the police if two adjacent houses are broken into. Give an efficient algorithm to determine the maximum amount of money you can steal without alerting the police.


:[[10.3]]. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible mixes (1s,2s,3s) of scoring add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are four possible solutions: (5, 0, 0), (2, 0, 1), (1, 2, 0), and (0, 1, 1).
[[10.3|Solution]]


:10.4. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible scoring sequences add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are thirteen possible sequences, including 1-2-1-1, 3-2, and 1-1-1-1-1.


:[[10.5]]. Given an &lt;math&gt;s * t&lt;/math&gt; grid filled with non-negative numbers, find a path from top left to bottom right that minimizes the sum of all numbers along its path. You can only move either down or right at any point in time.
::(a) Give a solution based on Dijkstra’s algorithm. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
::(b) Give a solution based on dynamic programming. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
[[10.5|Solution]]

===Edit Distance===

:10.6. Typists often make transposition errors exchanging neighboring characters, such as typing “setve” for “steve.” This requires two substitutions to fix under the conventional definition of edit distance.
:Incorporate a swap operation into our edit distance function, so that such neigh-
boring transposition errors can be fixed at the cost of one operation.


:[[10.7]]. Suppose you are given three strings of characters: &lt;math&gt;X&lt;/math&gt;, &lt;math&gt;Y&lt;/math&gt;, and &lt;math&gt;Z&lt;/math&gt;, where &lt;math&gt;|X| = n&lt;/math&gt;, &lt;math&gt;|Y| = m&lt;/math&gt;, and &lt;math&gt;|Z| = n + m&lt;/math&gt;. &lt;math&gt;Z&lt;/math&gt; is said to be a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; iff &lt;math&gt;Z&lt;/math&gt; can be formed by interleaving the characters from &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; in a way that maintains the left-to-right ordering of the characters from each string. 
:(a) Show that cchocohilaptes is a shuffle of chocolate and chips, but chocochilatspe is not.
:(b) Give an efficient dynamic programming algorithm that determines whether &lt;math&gt;Z&lt;/math&gt; is a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt;. (Hint: the values of the dynamic programming matrix you construct should be Boolean, not numeric.)
[[10.7|Solution]]


:10.8. The longest common substring (not subsequence) of two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; is the longest string that appears as a run of consecutive letters in both strings. For example, the longest common substring of photograph and tomography is ograph.
:(a) Let &lt;math&gt;n = |X|&lt;/math&gt; and &lt;math&gt;m = |Y|&lt;/math&gt;. Give a &lt;math&gt;\Theta (nm)&lt;/math&gt; dynamic programming algorithm for longest common substring based on the longest common subsequence/edit distance algorithm.
:(b) Give a simpler &lt;math&gt;\Theta (nm)&lt;/math&gt; algorithm that does not rely on dynamic programming.


:[[10.9]]. The ''longest common subsequence (LCS)'' of two sequences &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the longest sequence &lt;math&gt;L&lt;/math&gt; such that &lt;math&gt;L&lt;/math&gt; is a subsequence of both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;. The ''shortest common supersequence (SCS)'' of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the smallest sequence &lt;math&gt;L&lt;/math&gt; such that both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; are a subsequence of &lt;math&gt;L&lt;/math&gt;.
:(a) Give efficient algorithms to find the LCS and SCS of two given sequences.
:(b) Let &lt;math&gt;d(T, P)&lt;/math&gt; be the minimum edit distance between &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; when no substitutions are allowed (i.e., the only changes are character insertion and deletion). Prove that &lt;math&gt;d(T, P) = |SCS(T, P)| - |LCS(T, P)|&lt;/math&gt; where &lt;math&gt;|SCS(T, P)| (|LCS(T, P)|)&lt;/math&gt; is the size of the shortest SCS (longest LCS) of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;.
[[10.9|Solution]]


:10.10. Suppose you are given &lt;math&gt;n&lt;/math&gt; poker chips stacked in two stacks, where the edges of all chips can be seen. Each chip is one of three colors. A turn consists of choosing a color and removing all chips of that color from the tops of the stacks. The goal is to minimize the number of turns until the chips are gone. 
:For example, consider the stacks &lt;math&gt;(RRGG, GBBB)&lt;/math&gt;. Playing red, green, and then blue suffices to clear the stacks in three moves. Give an &lt;math&gt;O(n^2)&lt;/math&gt; dynamic programming algorithm to find the best strategy for a given pair of chip piles.

===Greedy Algorithms===

:[[10.11]]. Let &lt;math&gt;P_1, P_2, . . . , P_n&lt;/math&gt; be &lt;math&gt;n&lt;/math&gt; programs to be stored on a disk with capacity &lt;math&gt;D&lt;/math&gt; megabytes. Program &lt;math&gt;P_i&lt;/math&gt; requires &lt;math&gt;s_i&lt;/math&gt; megabytes of storage. We cannot store them all because &lt;math&gt;D &lt; \sum_{i=1}^n s_i &lt;/math&gt;
:(a) Does a greedy algorithm that selects programs in order of non-decreasing &lt;math&gt;s_i&lt;/math&gt; maximize the number of programs held on the disk? Prove or give a counter-example.
:(b) Does a greedy algorithm that selects programs in order of non-increasing &lt;math&gt;s_i&lt;/math&gt; use as much of the capacity of the disk as possible? Prove or give a counter-example.
[[10.11|Solution]]


:10.12. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We seek an algorithm to make change of &lt;math&gt;n&lt;/math&gt; units using the minimum number of this country’s coins.
:(a) The greedy algorithm repeatedly selects the biggest coin no bigger than the amount to be changed and repeats until it is zero. Show that the greedy algorithm does not always use the minimum number of coins in a country whose denominations are {1, 6, 10}.
:(b) Give an efficient algorithm that correctly determines the minimum number of coins needed to make change of &lt;math&gt;n&lt;/math&gt; units using denominations &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt;. Analyze its running time.


:[[10.13]]. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We want to count how many distinct ways &lt;math&gt;C(n)&lt;/math&gt; there are to make change of &lt;math&gt;n&lt;/math&gt; units. For example, in a country whose denominations are {1, 6, 10}, &lt;math&gt;C(5) = 1&lt;/math&gt;, &lt;math&gt;C(6)&lt;/math&gt; to &lt;math&gt;C(9) = 2&lt;/math&gt;, &lt;math&gt;C(10) = 3&lt;/math&gt;, and &lt;math&gt;C(12) = 4&lt;/math&gt;.
:(a) How many ways are there to make change of 20 units from {1, 6, 10}?
:(b) Give an efficient algorithm to compute &lt;math&gt;C(n)&lt;/math&gt;, and analyze its complexity. (Hint: think in terms of computing &lt;math&gt;C(n, d)&lt;/math&gt;, the number of ways to make change of &lt;math&gt;n&lt;/math&gt; units with highest denomination &lt;math&gt;d&lt;/math&gt;. Be careful to avoid overcounting.)
[[10.13|Solution]]


:10.14. In the single-processor scheduling problem, we are given a set of &lt;math&gt;n&lt;/math&gt; jobs &lt;math&gt;J&lt;/math&gt;. Each job &lt;math&gt;i&lt;/math&gt; has a processing time &lt;math&gt;t_i&lt;/math&gt;, and a deadline &lt;math&gt;d_i&lt;/math&gt;. A feasible schedule is a permutation of the jobs such that when the jobs are performed in that order, every job is finished before its deadline. The greedy algorithm for single-processor scheduling selects the job with the earliest deadline first.
:Show that if a feasible schedule exists, then the schedule produced by this greedy algorithm is feasible.

===Number Problems===

:[[10.15]]. You are given a rod of length &lt;math&gt;n&lt;/math&gt; inches and a table of prices obtainable for rod-pieces of size &lt;math&gt;n&lt;/math&gt; or smaller. Give an efficient algorithm to find the maximum value obtainable by cutting up the rod and selling the pieces. For example, if &lt;math&gt;n=8&lt;/math&gt; and the values of different pieces are:
&lt;center&gt;
\begin{array}{|C|rrrrrrrr} length &amp; 1 &amp; 2 &amp; 3 &amp; 4 &amp; 5 &amp; 6 &amp; 7 &amp; 8 \\
\hline
price &amp; 1 &amp; 5 &amp; 8 &amp; 9 &amp; 10 &amp; 17 &amp;17 &amp; 20 \\
\end{array}
&lt;/center&gt;
:then the maximum obtainable value is 22, by cutting into pieces of lengths 2 and 6.
[[10.15|Solution]]


:10.16. Your boss has written an arithmetic expression of n terms to compute your annual bonus, but permits you to parenthesize it however you wish. Give an efficient algorithm to design the parenthesization to maximize the value. For the expression:
&lt;center&gt;&lt;math&gt;6 + 2 * 0 - 4&lt;/math&gt;&lt;/center&gt;
:there exist parenthesizations with values ranging from −32 to 2.


:[[10.17]]. Given a positive integer &lt;math&gt;n&lt;/math&gt;, find an efficient algorithm to compute the smallest number of perfect squares (e.g. 1, 4, 9, 16, . . .) that sum to &lt;math&gt;n&lt;/math&gt;. What is the running time of your algorithm?
[[10.17|Solution]]


:10.18. Given an array &lt;math&gt;A&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find an efficient algorithm to compute the largest sum of a continuous run. For &lt;math&gt;A = [-3, 2, 7, -3, 4, -2, 0, 1]&lt;/math&gt;, the largest such sum is 10, from the second through fifth positions.


:[[10.19]]. Two drivers have to divide up &lt;math&gt;m&lt;/math&gt; suitcases between them, where the weight of the &lt;math&gt;ith&lt;/math&gt; suitcase is &lt;math&gt;w_i&lt;/math&gt;. Give an efficient algorithm to divide up the loads so the two drivers carry equal weight, if possible.
[[10.19|Solution]]


:10.20. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = {s_1, s_2, . . . , s_n}&lt;/math&gt;, and a given target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; that adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, within &lt;math&gt;S = {1, 2, 5, 9, 10}&lt;/math&gt; there is a subset that adds up to &lt;math&gt;T = 22&lt;/math&gt; but not &lt;math&gt;T = 23&lt;/math&gt;.
:Give a dynamic programming algorithm for knapsack that runs in &lt;math&gt;O(nT)&lt;/math&gt; time.


:[[10.21]]. The integer partition takes a set of positive integers &lt;math&gt;S = {s_1, . . . , s_n}&lt;/math&gt; and seeks a subset &lt;math&gt;I \subset S&lt;/math&gt; such that
&lt;center&gt;&lt;math&gt; \sum_{i \in I} s_i = \sum_{i \notin I} s_i&lt;/math&gt;&lt;/center&gt;
:Let &lt;math&gt; \sum_{i \in S} s_i = M &lt;/math&gt;. Give an &lt;math&gt;O(nM)&lt;/math&gt; dynamic programming algorithm to solve the integer partition problem.
[[10.21|Solution]]


:10.22. Assume that there are n numbers (some possibly negative) on a circle, and we wish to find the maximum contiguous sum along an arc of the circle. Give an efficient algorithm for solving this problem.


:[[10.23]]. A certain string processing language allows the programmer to break a string into two pieces. It costs &lt;math&gt;n&lt;/math&gt; units of time to break a string of &lt;math&gt;n&lt;/math&gt; characters into two pieces, since this involves copying the old string. A programmer wants to break a string into many pieces, and the order in which the breaks are made can affect the total amount of time used. For example, suppose we wish to break a 20-character string after characters 3, 8, and 10. If the breaks are made in left-to-right order, then the first break costs 20 units of time, the second break costs 17 units of time, and the third break costs 12 units of time, for a total of 49 units. If the breaks are made in right-to-left order, the first break costs 20 units of time, the second break costs 10 units of time, and the third break costs 8 units of time, for a total of only 38 units.
:Give a dynamic programming algorithm that takes a list of character positions after which to break and determines the cheapest break cost in &lt;math&gt;O(n^3)&lt;/math&gt; time.
[[10.23|Solution]]


:10.24. Consider the following data compression technique. We have a table of &lt;math&gt;m&lt;/math&gt; text strings, each at most &lt;math&gt;k&lt;/math&gt; in length. We want to encode a data string &lt;math&gt;D&lt;/math&gt; of length &lt;math&gt;n&lt;/math&gt; using as few text strings as possible. For example, if our table contains &lt;math&gt;(a,ba,abab,b)&lt;/math&gt; and the data string is &lt;math&gt;bababbaababa&lt;/math&gt;, the best way to encode it is &lt;math&gt;(b,abab,ba,abab,a)-a&lt;/math&gt; total of five code words. Give an &lt;math&gt;O(nmk)&lt;/math&gt; algorithm to find the length of the best encoding. You may assume that every string has at least one encoding in terms of the table.


:[[10.25]]. The traditional world chess championship is a match of 24 games. The current champion retains the title in case the match is a tie. Each game ends in a win, loss, or draw (tie) where wins count as 1, losses as 0, and draws as &lt;math&gt;1/2&lt;/math&gt;. The players take turns playing white and black. White plays first and so has an advantage. The champion plays white in the first game. The champ has probabilities &lt;math&gt;w_w&lt;/math&gt;, &lt;math&gt;w_d&lt;/math&gt;, and &lt;math&gt;w_l&lt;/math&gt; of winning, drawing, and losing playing white, and has probabilities &lt;math&gt;b_w&lt;/math&gt;, &lt;math&gt;b_d&lt;/math&gt;, and &lt;math&gt;b_l&lt;/math&gt; of winning, drawing, and losing playing black.
:(a) Write a recurrence for the probability that the champion retains the title. Assume that there are &lt;math&gt;g&lt;/math&gt; games left to play in the match and that the champion needs to get &lt;math&gt;i&lt;/math&gt; points (which may be a multiple of &lt;math&gt;1/2&lt;/math&gt;).
:(b) Based on your recurrence, give a dynamic programming algorithm to calculate the champion’s probability of retaining the title.
:(c) Analyze its running time for an &lt;math&gt;n&lt;/math&gt; game match.
[[10.125|Solution]]


:10.26. Eggs break when dropped from great enough height. Specifically, there must be a floor &lt;math&gt;f&lt;/math&gt; in any sufficiently tall building such that an egg dropped from the &lt;math&gt;f&lt;/math&gt;th floor breaks, but one dropped from the &lt;math&gt;(f - 1)&lt;/math&gt;st floor will not. If the egg always breaks, then &lt;math&gt;f = 1&lt;/math&gt;. If the egg never breaks, then &lt;math&gt;f = n + 1&lt;/math&gt;. 
:You seek to find the critical floor &lt;math&gt;f&lt;/math&gt; using an &lt;math&gt;n-floor&lt;/math&gt; building. The only operation you can perform is to drop an egg off some floor and see what happens. You start out with &lt;math&gt;k&lt;/math&gt; eggs, and seek to make as few drops as possible. Broken eggs cannot be reused. Let &lt;math&gt;E(k, n)&lt;/math&gt; be the minimum number of egg drops that will always suffice.
:(a) Show that &lt;math&gt;E(1, n) = n&lt;/math&gt;.
:(b) Show that &lt;math&gt;E(k, n) = \Theta (n^{1/k})&lt;/math&gt;.
:(c) Find a recurrence for &lt;math&gt;E(k, n)&lt;/math&gt;. What is the running time of the dynamic program to find &lt;math&gt;E(k, n)&lt;/math&gt;?

===Graphing Problem===

:[[10.27]]. Consider a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. 
:Unfortunately, the city has bad neighborhoods, whose intersections we do not want to walk in. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is in a neighborhood to avoid.
:(a) Give an example of the contents of bad such that there is no path across the grid avoiding bad neighborhoods.
:(b) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find a path across the grid that avoids bad neighborhoods.
:(c) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find the shortest path across the grid that avoids bad neighborhoods. You may assume that all blocks are of equal length. For partial credit, give an &lt;math&gt;O(X^2Y^2)&lt;/math&gt; algorithm.
[[10.27|Solution]]


:10.28. Consider the same situation as the previous problem. We have a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is somewhere we want to avoid.
:If there were no bad neighborhoods to contend with, the shortest path across the grid would have length &lt;math&gt;(X - 1) + (Y - 1)&lt;/math&gt; blocks, and indeed there would be many such paths across the grid. Each path would consist of only rightward and downward moves.
:Give an algorithm that takes the array bad and returns the number of safe paths of length &lt;math&gt;X + Y - 2&lt;/math&gt;. For full credit, your algorithm must run in &lt;math&gt;O(XY)&lt;/math&gt;.


:[[10.29]]. You seek to create a stack out of &lt;math&gt;n&lt;/math&gt; boxes, where box &lt;math&gt;i&lt;/math&gt; has width &lt;math&gt;w_i&lt;/math&gt;, height &lt;math&gt;h_i&lt;/math&gt;, and depth &lt;math&gt;d_i&lt;/math&gt;. The boxes cannot be rotated, and can only be stacked on top of one another when each box in the stack is strictly larger than the box above it in width, height, and depth. Give an efficient algorithm to construct the tallest possible stack, where the height is the sum of the heights of each box in the stack.
[[10.29|Solution]]

===Design Problems===

:10.30. Consider the problem of storing &lt;math&gt;n&lt;/math&gt; books on shelves in a library. The order of the books is fixed by the cataloging system and so cannot be rearranged. Therefore, we can speak of a book &lt;math&gt;b_i&lt;/math&gt;, where &lt;math&gt;1 \leq i \leq n&lt;/math&gt;, that has a thickness &lt;math&gt;t_i&lt;/math&gt; and height &lt;math&gt;h_i&lt;/math&gt;. The length of each bookshelf at this library is &lt;math&gt;L&lt;/math&gt;.
:Suppose all the books have the same height &lt;math&gt;h&lt;/math&gt; (i.e., &lt;math&gt;h = h_i&lt;/math&gt; for all &lt;math&gt;i&lt;/math&gt;) and the shelves are all separated by a distance greater than &lt;math&gt;h&lt;/math&gt;, so any book fits on any shelf. The greedy algorithm would fill the first shelf with as many books as we can until we get the smallest &lt;math&gt;i&lt;/math&gt; such that &lt;math&gt;b_i&lt;/math&gt; does not fit, and then repeat with subsequent shelves. Show that the greedy algorithm always finds the book placement that uses the minimum number of shelves, and analyze its time complexity.


:[[10.31]]. This is a generalization of the previous problem. Now consider the case where the height of the books is not constant, but we have the freedom to adjust the height of each shelf to that of the tallest book on the shelf. Here the cost of a particular layout is the sum of the heights of the largest book on each shelf.
:#Give an example to show that the greedy algorithm of stuffing each shelf as full as possible does not always give the minimum overall height.
:#Give an algorithm for this problem, and analyze its time complexity. (Hint: use dynamic programming.)
[[10.31|Solution]]


:10.32. Consider a linear keyboard of lowercase letters and numbers, where the left-most 26 keys are the letters A–Z in order, followed by the digits 0–9 in order, followed by the 30 punctuation characters in a prescribed order, and ended on a blank. Assume you start with your left index finger on the “A” and your right index finger on the blank.
:Give a dynamic programming algorithm that finds the most efficient way to type a given text of length &lt;math&gt;n&lt;/math&gt;, in terms of minimizing total movement of the fingers involved. For the text &lt;math&gt;ABABABAB . . . ABAB&lt;/math&gt;, this would involve shifting both fingers all the way to the left side of the keyboard. Analyze the complexity of your algorithm as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;, the number of keys on the keyboard.


:[[10.33]]. You have come back from the future with an array &lt;math&gt;G&lt;/math&gt;, where &lt;math&gt;G[i]&lt;/math&gt; tells you the price of Google stock &lt;math&gt;i&lt;/math&gt; days from now, for &lt;math&gt;1 \leq i \leq n&lt;/math&gt;. You seek to use this information to maximize your profit, but are only permitted to complete at most one transaction (i.e. either buy one or sell one share of the stock) per day. Design an efficient algorithm to construct the buy–sell sequence to maximize your profit. Note that you cannot sell a share unless you currently own one.
[[10.33|Solution]]


:10.34. You are given a string of &lt;math&gt;n&lt;/math&gt; characters &lt;math&gt;S = s_1 . . . s_n&lt;/math&gt;, which you believe to be a compressed text document in which all spaces have been removed, like '''itwasthebestoftimes'''.
:(a) You seek to reconstruct the document using a dictionary, which is available in the form of a Boolean function &lt;math&gt;dict(w)&lt;/math&gt;, where &lt;math&gt;dict(w)&lt;/math&gt; is true iff string &lt;math&gt;w&lt;/math&gt; is a valid word in the language. Give an &lt;math&gt;O(n^2)&lt;/math&gt; algorithm to determine whether string &lt;math&gt;S&lt;/math&gt; can be reconstituted as a sequence of valid words, assuming calls to &lt;math&gt;dict(w)&lt;/math&gt; take unit time.
:(b) Now assume you are given the dictionary as a set of &lt;math&gt;m&lt;/math&gt; words each of length at most l. Give an efficient algorithm to determine whether string &lt;math&gt;S&lt;/math&gt; can be reconstituted as a sequence of valid words, and its running time.


:[[10.35]]. Consider the following two-player game, where you seek to get the biggest score. You start with an n-digit integer &lt;math&gt;N&lt;/math&gt;. With each move, you get to take either the first digit or the last digit from what is left of &lt;math&gt;N&lt;/math&gt;, and add that to your score, with your opponent then doing the same thing to the now smaller number. You continue taking turns removing digits until none are left. Give an efficient algorithm that finds the best possible score that the first player can get for a given digit string &lt;math&gt;N&lt;/math&gt;, assuming the second player is as smart as can be.
[[10.35|Solution]]


:10.36. Given an array of &lt;math&gt;n&lt;/math&gt; real numbers, consider the problem of finding the maximum sum in any contiguous subarray of the input. For example, in the array
&lt;center&gt;&lt;math&gt;[31, -41, 59, 26, -53, 58, 97, -93, -23, 84]&lt;/math&gt;&lt;/center&gt;
:the maximum is achieved by summing the third through seventh elements, where 59 + 26 + (−53) + 58 + 97 = 187. When all numbers are positive, the entire array is the answer, while when all numbers are negative, the empty array maximizes the total at 0.
#Give a simple and clear &lt;math&gt; \Theta (n^2)&lt;/math&gt;-time algorithm to find the maximum contiguous subarray.
#Now give a &lt;math&gt;\Theta (n)&lt;/math&gt;-time dynamic programming algorithm for this problem. To get partial credit, you may instead give a correct &lt;math&gt;O(n log n)&lt;/math&gt; divide-and-conquer algorithm.


:[[10.37]]


:10.38. Let α and β be constants. Assume that it costs α to go left in a binary search tree, and β to go right. Devise an algorithm that builds a tree with optimal expected query cost, given keys &lt;math&gt;k_1, . . . , k_n&lt;/math&gt; and the probabilities that each will be searched &lt;math&gt;p_1, . . . , p_n&lt;/math&gt;.

===Interview Problems===

:[[10.39]]


:10.40


:[[10.41]]


Back to [[Chapter List]]</text>
      <sha1>j8fyokw8ifydyf5kk24styrtes7vz6j</sha1>
    </revision>
    <revision>
      <id>220</id>
      <parentid>219</parentid>
      <timestamp>2020-09-13T20:44:47Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Design Problems */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="22904">=Dynamic Programming=

===Elementary Recurrences===

:[[10.1]]. Up to &lt;math&gt;k&lt;/math&gt; steps in a single bound! A child is running up a staircase with &lt;math&gt;n&lt;/math&gt; steps and can hop between 1 and &lt;math&gt;k&lt;/math&gt; steps at a time. Design an algorithm to count how many possible ways the child can run up the stairs, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. What is the running time of your algorithm?
[[10.1|Solution]]


:10.2. Imagine you are a professional thief who plans to rob houses along a street of &lt;math&gt;n&lt;/math&gt; homes. You know the loot at house &lt;math&gt;i&lt;/math&gt; is worth &lt;math&gt;m_i&lt;/math&gt;, for &lt;math&gt;1 \le i \le n&lt;/math&gt;, but you cannot rob neighboring houses because their connected security systems will automatically contact the police if two adjacent houses are broken into. Give an efficient algorithm to determine the maximum amount of money you can steal without alerting the police.


:[[10.3]]. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible mixes (1s,2s,3s) of scoring add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are four possible solutions: (5, 0, 0), (2, 0, 1), (1, 2, 0), and (0, 1, 1).
[[10.3|Solution]]


:10.4. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible scoring sequences add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are thirteen possible sequences, including 1-2-1-1, 3-2, and 1-1-1-1-1.


:[[10.5]]. Given an &lt;math&gt;s * t&lt;/math&gt; grid filled with non-negative numbers, find a path from top left to bottom right that minimizes the sum of all numbers along its path. You can only move either down or right at any point in time.
::(a) Give a solution based on Dijkstra’s algorithm. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
::(b) Give a solution based on dynamic programming. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
[[10.5|Solution]]

===Edit Distance===

:10.6. Typists often make transposition errors exchanging neighboring characters, such as typing “setve” for “steve.” This requires two substitutions to fix under the conventional definition of edit distance.
:Incorporate a swap operation into our edit distance function, so that such neigh-
boring transposition errors can be fixed at the cost of one operation.


:[[10.7]]. Suppose you are given three strings of characters: &lt;math&gt;X&lt;/math&gt;, &lt;math&gt;Y&lt;/math&gt;, and &lt;math&gt;Z&lt;/math&gt;, where &lt;math&gt;|X| = n&lt;/math&gt;, &lt;math&gt;|Y| = m&lt;/math&gt;, and &lt;math&gt;|Z| = n + m&lt;/math&gt;. &lt;math&gt;Z&lt;/math&gt; is said to be a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; iff &lt;math&gt;Z&lt;/math&gt; can be formed by interleaving the characters from &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; in a way that maintains the left-to-right ordering of the characters from each string. 
:(a) Show that cchocohilaptes is a shuffle of chocolate and chips, but chocochilatspe is not.
:(b) Give an efficient dynamic programming algorithm that determines whether &lt;math&gt;Z&lt;/math&gt; is a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt;. (Hint: the values of the dynamic programming matrix you construct should be Boolean, not numeric.)
[[10.7|Solution]]


:10.8. The longest common substring (not subsequence) of two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; is the longest string that appears as a run of consecutive letters in both strings. For example, the longest common substring of photograph and tomography is ograph.
:(a) Let &lt;math&gt;n = |X|&lt;/math&gt; and &lt;math&gt;m = |Y|&lt;/math&gt;. Give a &lt;math&gt;\Theta (nm)&lt;/math&gt; dynamic programming algorithm for longest common substring based on the longest common subsequence/edit distance algorithm.
:(b) Give a simpler &lt;math&gt;\Theta (nm)&lt;/math&gt; algorithm that does not rely on dynamic programming.


:[[10.9]]. The ''longest common subsequence (LCS)'' of two sequences &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the longest sequence &lt;math&gt;L&lt;/math&gt; such that &lt;math&gt;L&lt;/math&gt; is a subsequence of both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;. The ''shortest common supersequence (SCS)'' of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the smallest sequence &lt;math&gt;L&lt;/math&gt; such that both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; are a subsequence of &lt;math&gt;L&lt;/math&gt;.
:(a) Give efficient algorithms to find the LCS and SCS of two given sequences.
:(b) Let &lt;math&gt;d(T, P)&lt;/math&gt; be the minimum edit distance between &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; when no substitutions are allowed (i.e., the only changes are character insertion and deletion). Prove that &lt;math&gt;d(T, P) = |SCS(T, P)| - |LCS(T, P)|&lt;/math&gt; where &lt;math&gt;|SCS(T, P)| (|LCS(T, P)|)&lt;/math&gt; is the size of the shortest SCS (longest LCS) of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;.
[[10.9|Solution]]


:10.10. Suppose you are given &lt;math&gt;n&lt;/math&gt; poker chips stacked in two stacks, where the edges of all chips can be seen. Each chip is one of three colors. A turn consists of choosing a color and removing all chips of that color from the tops of the stacks. The goal is to minimize the number of turns until the chips are gone. 
:For example, consider the stacks &lt;math&gt;(RRGG, GBBB)&lt;/math&gt;. Playing red, green, and then blue suffices to clear the stacks in three moves. Give an &lt;math&gt;O(n^2)&lt;/math&gt; dynamic programming algorithm to find the best strategy for a given pair of chip piles.

===Greedy Algorithms===

:[[10.11]]. Let &lt;math&gt;P_1, P_2, . . . , P_n&lt;/math&gt; be &lt;math&gt;n&lt;/math&gt; programs to be stored on a disk with capacity &lt;math&gt;D&lt;/math&gt; megabytes. Program &lt;math&gt;P_i&lt;/math&gt; requires &lt;math&gt;s_i&lt;/math&gt; megabytes of storage. We cannot store them all because &lt;math&gt;D &lt; \sum_{i=1}^n s_i &lt;/math&gt;
:(a) Does a greedy algorithm that selects programs in order of non-decreasing &lt;math&gt;s_i&lt;/math&gt; maximize the number of programs held on the disk? Prove or give a counter-example.
:(b) Does a greedy algorithm that selects programs in order of non-increasing &lt;math&gt;s_i&lt;/math&gt; use as much of the capacity of the disk as possible? Prove or give a counter-example.
[[10.11|Solution]]


:10.12. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We seek an algorithm to make change of &lt;math&gt;n&lt;/math&gt; units using the minimum number of this country’s coins.
:(a) The greedy algorithm repeatedly selects the biggest coin no bigger than the amount to be changed and repeats until it is zero. Show that the greedy algorithm does not always use the minimum number of coins in a country whose denominations are {1, 6, 10}.
:(b) Give an efficient algorithm that correctly determines the minimum number of coins needed to make change of &lt;math&gt;n&lt;/math&gt; units using denominations &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt;. Analyze its running time.


:[[10.13]]. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We want to count how many distinct ways &lt;math&gt;C(n)&lt;/math&gt; there are to make change of &lt;math&gt;n&lt;/math&gt; units. For example, in a country whose denominations are {1, 6, 10}, &lt;math&gt;C(5) = 1&lt;/math&gt;, &lt;math&gt;C(6)&lt;/math&gt; to &lt;math&gt;C(9) = 2&lt;/math&gt;, &lt;math&gt;C(10) = 3&lt;/math&gt;, and &lt;math&gt;C(12) = 4&lt;/math&gt;.
:(a) How many ways are there to make change of 20 units from {1, 6, 10}?
:(b) Give an efficient algorithm to compute &lt;math&gt;C(n)&lt;/math&gt;, and analyze its complexity. (Hint: think in terms of computing &lt;math&gt;C(n, d)&lt;/math&gt;, the number of ways to make change of &lt;math&gt;n&lt;/math&gt; units with highest denomination &lt;math&gt;d&lt;/math&gt;. Be careful to avoid overcounting.)
[[10.13|Solution]]


:10.14. In the single-processor scheduling problem, we are given a set of &lt;math&gt;n&lt;/math&gt; jobs &lt;math&gt;J&lt;/math&gt;. Each job &lt;math&gt;i&lt;/math&gt; has a processing time &lt;math&gt;t_i&lt;/math&gt;, and a deadline &lt;math&gt;d_i&lt;/math&gt;. A feasible schedule is a permutation of the jobs such that when the jobs are performed in that order, every job is finished before its deadline. The greedy algorithm for single-processor scheduling selects the job with the earliest deadline first.
:Show that if a feasible schedule exists, then the schedule produced by this greedy algorithm is feasible.

===Number Problems===

:[[10.15]]. You are given a rod of length &lt;math&gt;n&lt;/math&gt; inches and a table of prices obtainable for rod-pieces of size &lt;math&gt;n&lt;/math&gt; or smaller. Give an efficient algorithm to find the maximum value obtainable by cutting up the rod and selling the pieces. For example, if &lt;math&gt;n=8&lt;/math&gt; and the values of different pieces are:
&lt;center&gt;
\begin{array}{|C|rrrrrrrr} length &amp; 1 &amp; 2 &amp; 3 &amp; 4 &amp; 5 &amp; 6 &amp; 7 &amp; 8 \\
\hline
price &amp; 1 &amp; 5 &amp; 8 &amp; 9 &amp; 10 &amp; 17 &amp;17 &amp; 20 \\
\end{array}
&lt;/center&gt;
:then the maximum obtainable value is 22, by cutting into pieces of lengths 2 and 6.
[[10.15|Solution]]


:10.16. Your boss has written an arithmetic expression of n terms to compute your annual bonus, but permits you to parenthesize it however you wish. Give an efficient algorithm to design the parenthesization to maximize the value. For the expression:
&lt;center&gt;&lt;math&gt;6 + 2 * 0 - 4&lt;/math&gt;&lt;/center&gt;
:there exist parenthesizations with values ranging from −32 to 2.


:[[10.17]]. Given a positive integer &lt;math&gt;n&lt;/math&gt;, find an efficient algorithm to compute the smallest number of perfect squares (e.g. 1, 4, 9, 16, . . .) that sum to &lt;math&gt;n&lt;/math&gt;. What is the running time of your algorithm?
[[10.17|Solution]]


:10.18. Given an array &lt;math&gt;A&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find an efficient algorithm to compute the largest sum of a continuous run. For &lt;math&gt;A = [-3, 2, 7, -3, 4, -2, 0, 1]&lt;/math&gt;, the largest such sum is 10, from the second through fifth positions.


:[[10.19]]. Two drivers have to divide up &lt;math&gt;m&lt;/math&gt; suitcases between them, where the weight of the &lt;math&gt;ith&lt;/math&gt; suitcase is &lt;math&gt;w_i&lt;/math&gt;. Give an efficient algorithm to divide up the loads so the two drivers carry equal weight, if possible.
[[10.19|Solution]]


:10.20. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = {s_1, s_2, . . . , s_n}&lt;/math&gt;, and a given target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; that adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, within &lt;math&gt;S = {1, 2, 5, 9, 10}&lt;/math&gt; there is a subset that adds up to &lt;math&gt;T = 22&lt;/math&gt; but not &lt;math&gt;T = 23&lt;/math&gt;.
:Give a dynamic programming algorithm for knapsack that runs in &lt;math&gt;O(nT)&lt;/math&gt; time.


:[[10.21]]. The integer partition takes a set of positive integers &lt;math&gt;S = {s_1, . . . , s_n}&lt;/math&gt; and seeks a subset &lt;math&gt;I \subset S&lt;/math&gt; such that
&lt;center&gt;&lt;math&gt; \sum_{i \in I} s_i = \sum_{i \notin I} s_i&lt;/math&gt;&lt;/center&gt;
:Let &lt;math&gt; \sum_{i \in S} s_i = M &lt;/math&gt;. Give an &lt;math&gt;O(nM)&lt;/math&gt; dynamic programming algorithm to solve the integer partition problem.
[[10.21|Solution]]


:10.22. Assume that there are n numbers (some possibly negative) on a circle, and we wish to find the maximum contiguous sum along an arc of the circle. Give an efficient algorithm for solving this problem.


:[[10.23]]. A certain string processing language allows the programmer to break a string into two pieces. It costs &lt;math&gt;n&lt;/math&gt; units of time to break a string of &lt;math&gt;n&lt;/math&gt; characters into two pieces, since this involves copying the old string. A programmer wants to break a string into many pieces, and the order in which the breaks are made can affect the total amount of time used. For example, suppose we wish to break a 20-character string after characters 3, 8, and 10. If the breaks are made in left-to-right order, then the first break costs 20 units of time, the second break costs 17 units of time, and the third break costs 12 units of time, for a total of 49 units. If the breaks are made in right-to-left order, the first break costs 20 units of time, the second break costs 10 units of time, and the third break costs 8 units of time, for a total of only 38 units.
:Give a dynamic programming algorithm that takes a list of character positions after which to break and determines the cheapest break cost in &lt;math&gt;O(n^3)&lt;/math&gt; time.
[[10.23|Solution]]


:10.24. Consider the following data compression technique. We have a table of &lt;math&gt;m&lt;/math&gt; text strings, each at most &lt;math&gt;k&lt;/math&gt; in length. We want to encode a data string &lt;math&gt;D&lt;/math&gt; of length &lt;math&gt;n&lt;/math&gt; using as few text strings as possible. For example, if our table contains &lt;math&gt;(a,ba,abab,b)&lt;/math&gt; and the data string is &lt;math&gt;bababbaababa&lt;/math&gt;, the best way to encode it is &lt;math&gt;(b,abab,ba,abab,a)-a&lt;/math&gt; total of five code words. Give an &lt;math&gt;O(nmk)&lt;/math&gt; algorithm to find the length of the best encoding. You may assume that every string has at least one encoding in terms of the table.


:[[10.25]]. The traditional world chess championship is a match of 24 games. The current champion retains the title in case the match is a tie. Each game ends in a win, loss, or draw (tie) where wins count as 1, losses as 0, and draws as &lt;math&gt;1/2&lt;/math&gt;. The players take turns playing white and black. White plays first and so has an advantage. The champion plays white in the first game. The champ has probabilities &lt;math&gt;w_w&lt;/math&gt;, &lt;math&gt;w_d&lt;/math&gt;, and &lt;math&gt;w_l&lt;/math&gt; of winning, drawing, and losing playing white, and has probabilities &lt;math&gt;b_w&lt;/math&gt;, &lt;math&gt;b_d&lt;/math&gt;, and &lt;math&gt;b_l&lt;/math&gt; of winning, drawing, and losing playing black.
:(a) Write a recurrence for the probability that the champion retains the title. Assume that there are &lt;math&gt;g&lt;/math&gt; games left to play in the match and that the champion needs to get &lt;math&gt;i&lt;/math&gt; points (which may be a multiple of &lt;math&gt;1/2&lt;/math&gt;).
:(b) Based on your recurrence, give a dynamic programming algorithm to calculate the champion’s probability of retaining the title.
:(c) Analyze its running time for an &lt;math&gt;n&lt;/math&gt; game match.
[[10.125|Solution]]


:10.26. Eggs break when dropped from great enough height. Specifically, there must be a floor &lt;math&gt;f&lt;/math&gt; in any sufficiently tall building such that an egg dropped from the &lt;math&gt;f&lt;/math&gt;th floor breaks, but one dropped from the &lt;math&gt;(f - 1)&lt;/math&gt;st floor will not. If the egg always breaks, then &lt;math&gt;f = 1&lt;/math&gt;. If the egg never breaks, then &lt;math&gt;f = n + 1&lt;/math&gt;. 
:You seek to find the critical floor &lt;math&gt;f&lt;/math&gt; using an &lt;math&gt;n-floor&lt;/math&gt; building. The only operation you can perform is to drop an egg off some floor and see what happens. You start out with &lt;math&gt;k&lt;/math&gt; eggs, and seek to make as few drops as possible. Broken eggs cannot be reused. Let &lt;math&gt;E(k, n)&lt;/math&gt; be the minimum number of egg drops that will always suffice.
:(a) Show that &lt;math&gt;E(1, n) = n&lt;/math&gt;.
:(b) Show that &lt;math&gt;E(k, n) = \Theta (n^{1/k})&lt;/math&gt;.
:(c) Find a recurrence for &lt;math&gt;E(k, n)&lt;/math&gt;. What is the running time of the dynamic program to find &lt;math&gt;E(k, n)&lt;/math&gt;?

===Graphing Problem===

:[[10.27]]. Consider a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. 
:Unfortunately, the city has bad neighborhoods, whose intersections we do not want to walk in. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is in a neighborhood to avoid.
:(a) Give an example of the contents of bad such that there is no path across the grid avoiding bad neighborhoods.
:(b) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find a path across the grid that avoids bad neighborhoods.
:(c) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find the shortest path across the grid that avoids bad neighborhoods. You may assume that all blocks are of equal length. For partial credit, give an &lt;math&gt;O(X^2Y^2)&lt;/math&gt; algorithm.
[[10.27|Solution]]


:10.28. Consider the same situation as the previous problem. We have a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is somewhere we want to avoid.
:If there were no bad neighborhoods to contend with, the shortest path across the grid would have length &lt;math&gt;(X - 1) + (Y - 1)&lt;/math&gt; blocks, and indeed there would be many such paths across the grid. Each path would consist of only rightward and downward moves.
:Give an algorithm that takes the array bad and returns the number of safe paths of length &lt;math&gt;X + Y - 2&lt;/math&gt;. For full credit, your algorithm must run in &lt;math&gt;O(XY)&lt;/math&gt;.


:[[10.29]]. You seek to create a stack out of &lt;math&gt;n&lt;/math&gt; boxes, where box &lt;math&gt;i&lt;/math&gt; has width &lt;math&gt;w_i&lt;/math&gt;, height &lt;math&gt;h_i&lt;/math&gt;, and depth &lt;math&gt;d_i&lt;/math&gt;. The boxes cannot be rotated, and can only be stacked on top of one another when each box in the stack is strictly larger than the box above it in width, height, and depth. Give an efficient algorithm to construct the tallest possible stack, where the height is the sum of the heights of each box in the stack.
[[10.29|Solution]]

===Design Problems===

:10.30. Consider the problem of storing &lt;math&gt;n&lt;/math&gt; books on shelves in a library. The order of the books is fixed by the cataloging system and so cannot be rearranged. Therefore, we can speak of a book &lt;math&gt;b_i&lt;/math&gt;, where &lt;math&gt;1 \leq i \leq n&lt;/math&gt;, that has a thickness &lt;math&gt;t_i&lt;/math&gt; and height &lt;math&gt;h_i&lt;/math&gt;. The length of each bookshelf at this library is &lt;math&gt;L&lt;/math&gt;.
:Suppose all the books have the same height &lt;math&gt;h&lt;/math&gt; (i.e., &lt;math&gt;h = h_i&lt;/math&gt; for all &lt;math&gt;i&lt;/math&gt;) and the shelves are all separated by a distance greater than &lt;math&gt;h&lt;/math&gt;, so any book fits on any shelf. The greedy algorithm would fill the first shelf with as many books as we can until we get the smallest &lt;math&gt;i&lt;/math&gt; such that &lt;math&gt;b_i&lt;/math&gt; does not fit, and then repeat with subsequent shelves. Show that the greedy algorithm always finds the book placement that uses the minimum number of shelves, and analyze its time complexity.


:[[10.31]]. This is a generalization of the previous problem. Now consider the case where the height of the books is not constant, but we have the freedom to adjust the height of each shelf to that of the tallest book on the shelf. Here the cost of a particular layout is the sum of the heights of the largest book on each shelf.
:#Give an example to show that the greedy algorithm of stuffing each shelf as full as possible does not always give the minimum overall height.
:#Give an algorithm for this problem, and analyze its time complexity. (Hint: use dynamic programming.)
[[10.31|Solution]]


:10.32. Consider a linear keyboard of lowercase letters and numbers, where the left-most 26 keys are the letters A–Z in order, followed by the digits 0–9 in order, followed by the 30 punctuation characters in a prescribed order, and ended on a blank. Assume you start with your left index finger on the “A” and your right index finger on the blank.
:Give a dynamic programming algorithm that finds the most efficient way to type a given text of length &lt;math&gt;n&lt;/math&gt;, in terms of minimizing total movement of the fingers involved. For the text &lt;math&gt;ABABABAB . . . ABAB&lt;/math&gt;, this would involve shifting both fingers all the way to the left side of the keyboard. Analyze the complexity of your algorithm as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;, the number of keys on the keyboard.


:[[10.33]]. You have come back from the future with an array &lt;math&gt;G&lt;/math&gt;, where &lt;math&gt;G[i]&lt;/math&gt; tells you the price of Google stock &lt;math&gt;i&lt;/math&gt; days from now, for &lt;math&gt;1 \leq i \leq n&lt;/math&gt;. You seek to use this information to maximize your profit, but are only permitted to complete at most one transaction (i.e. either buy one or sell one share of the stock) per day. Design an efficient algorithm to construct the buy–sell sequence to maximize your profit. Note that you cannot sell a share unless you currently own one.
[[10.33|Solution]]


:10.34. You are given a string of &lt;math&gt;n&lt;/math&gt; characters &lt;math&gt;S = s_1 . . . s_n&lt;/math&gt;, which you believe to be a compressed text document in which all spaces have been removed, like '''itwasthebestoftimes'''.
:(a) You seek to reconstruct the document using a dictionary, which is available in the form of a Boolean function &lt;math&gt;dict(w)&lt;/math&gt;, where &lt;math&gt;dict(w)&lt;/math&gt; is true iff string &lt;math&gt;w&lt;/math&gt; is a valid word in the language. Give an &lt;math&gt;O(n^2)&lt;/math&gt; algorithm to determine whether string &lt;math&gt;S&lt;/math&gt; can be reconstituted as a sequence of valid words, assuming calls to &lt;math&gt;dict(w &lt;/math&gt; take unit time.
:(b) Now assume you are given the dictionary as a set of &lt;math&gt;m&lt;/math&gt; words each of length at most l. Give an efficient algorithm to determine whether string &lt;math&gt;S&lt;/math&gt; can be reconstituted as a sequence of valid words, and its running time.


:[[10.35]]. Consider the following two-player game, where you seek to get the biggest score. You start with an n-digit integer &lt;math&gt;N&lt;/math&gt;. With each move, you get to take either the first digit or the last digit from what is left of &lt;math&gt;N&lt;/math&gt;, and add that to your score, with your opponent then doing the same thing to the now smaller number. You continue taking turns removing digits until none are left. Give an efficient algorithm that finds the best possible score that the first player can get for a given digit string &lt;math&gt;N&lt;/math&gt;, assuming the second player is as smart as can be.
[[10.35|Solution]]


:10.36. Given an array of &lt;math&gt;n&lt;/math&gt; real numbers, consider the problem of finding the maximum sum in any contiguous subarray of the input. For example, in the array
&lt;center&gt;&lt;math&gt;[31, -41, 59, 26, -53, 58, 97, -93, -23, 84]&lt;/math&gt;&lt;/center&gt;
:the maximum is achieved by summing the third through seventh elements, where 59 + 26 + (−53) + 58 + 97 = 187. When all numbers are positive, the entire array is the answer, while when all numbers are negative, the empty array maximizes the total at 0.
#Give a simple and clear &lt;math&gt; \Theta (n^2)&lt;/math&gt;-time algorithm to find the maximum contiguous subarray.
#Now give a &lt;math&gt;\Theta (n)&lt;/math&gt;-time dynamic programming algorithm for this problem. To get partial credit, you may instead give a correct &lt;math&gt;O(n log n)&lt;/math&gt; divide-and-conquer algorithm.


:[[10.37]]


:10.38. Let α and β be constants. Assume that it costs α to go left in a binary search tree, and β to go right. Devise an algorithm that builds a tree with optimal expected query cost, given keys &lt;math&gt;k_1, . . . , k_n&lt;/math&gt; and the probabilities that each will be searched &lt;math&gt;p_1, . . . , p_n&lt;/math&gt;.

===Interview Problems===

:[[10.39]]


:10.40


:[[10.41]]


Back to [[Chapter List]]</text>
      <sha1>iaatnq9seiu16gpn41byy2zukcm94ve</sha1>
    </revision>
    <revision>
      <id>221</id>
      <parentid>220</parentid>
      <timestamp>2020-09-13T20:45:19Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Edit Distance */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="22902">=Dynamic Programming=

===Elementary Recurrences===

:[[10.1]]. Up to &lt;math&gt;k&lt;/math&gt; steps in a single bound! A child is running up a staircase with &lt;math&gt;n&lt;/math&gt; steps and can hop between 1 and &lt;math&gt;k&lt;/math&gt; steps at a time. Design an algorithm to count how many possible ways the child can run up the stairs, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. What is the running time of your algorithm?
[[10.1|Solution]]


:10.2. Imagine you are a professional thief who plans to rob houses along a street of &lt;math&gt;n&lt;/math&gt; homes. You know the loot at house &lt;math&gt;i&lt;/math&gt; is worth &lt;math&gt;m_i&lt;/math&gt;, for &lt;math&gt;1 \le i \le n&lt;/math&gt;, but you cannot rob neighboring houses because their connected security systems will automatically contact the police if two adjacent houses are broken into. Give an efficient algorithm to determine the maximum amount of money you can steal without alerting the police.


:[[10.3]]. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible mixes (1s,2s,3s) of scoring add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are four possible solutions: (5, 0, 0), (2, 0, 1), (1, 2, 0), and (0, 1, 1).
[[10.3|Solution]]


:10.4. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible scoring sequences add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are thirteen possible sequences, including 1-2-1-1, 3-2, and 1-1-1-1-1.


:[[10.5]]. Given an &lt;math&gt;s * t&lt;/math&gt; grid filled with non-negative numbers, find a path from top left to bottom right that minimizes the sum of all numbers along its path. You can only move either down or right at any point in time.
::(a) Give a solution based on Dijkstra’s algorithm. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
::(b) Give a solution based on dynamic programming. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
[[10.5|Solution]]

===Edit Distance===

:10.6. Typists often make transposition errors exchanging neighboring characters, such as typing “setve” for “steve.” This requires two substitutions to fix under the conventional definition of edit distance.
:Incorporate a swap operation into our edit distance function, so that such neighboring transposition errors can be fixed at the cost of one operation.


:[[10.7]]. Suppose you are given three strings of characters: &lt;math&gt;X&lt;/math&gt;, &lt;math&gt;Y&lt;/math&gt;, and &lt;math&gt;Z&lt;/math&gt;, where &lt;math&gt;|X| = n&lt;/math&gt;, &lt;math&gt;|Y| = m&lt;/math&gt;, and &lt;math&gt;|Z| = n + m&lt;/math&gt;. &lt;math&gt;Z&lt;/math&gt; is said to be a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; iff &lt;math&gt;Z&lt;/math&gt; can be formed by interleaving the characters from &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; in a way that maintains the left-to-right ordering of the characters from each string. 
:(a) Show that cchocohilaptes is a shuffle of chocolate and chips, but chocochilatspe is not.
:(b) Give an efficient dynamic programming algorithm that determines whether &lt;math&gt;Z&lt;/math&gt; is a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt;. (Hint: the values of the dynamic programming matrix you construct should be Boolean, not numeric.)
[[10.7|Solution]]


:10.8. The longest common substring (not subsequence) of two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; is the longest string that appears as a run of consecutive letters in both strings. For example, the longest common substring of photograph and tomography is ograph.
:(a) Let &lt;math&gt;n = |X|&lt;/math&gt; and &lt;math&gt;m = |Y|&lt;/math&gt;. Give a &lt;math&gt;\Theta (nm)&lt;/math&gt; dynamic programming algorithm for longest common substring based on the longest common subsequence/edit distance algorithm.
:(b) Give a simpler &lt;math&gt;\Theta (nm)&lt;/math&gt; algorithm that does not rely on dynamic programming.


:[[10.9]]. The ''longest common subsequence (LCS)'' of two sequences &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the longest sequence &lt;math&gt;L&lt;/math&gt; such that &lt;math&gt;L&lt;/math&gt; is a subsequence of both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;. The ''shortest common supersequence (SCS)'' of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the smallest sequence &lt;math&gt;L&lt;/math&gt; such that both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; are a subsequence of &lt;math&gt;L&lt;/math&gt;.
:(a) Give efficient algorithms to find the LCS and SCS of two given sequences.
:(b) Let &lt;math&gt;d(T, P)&lt;/math&gt; be the minimum edit distance between &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; when no substitutions are allowed (i.e., the only changes are character insertion and deletion). Prove that &lt;math&gt;d(T, P) = |SCS(T, P)| - |LCS(T, P)|&lt;/math&gt; where &lt;math&gt;|SCS(T, P)| (|LCS(T, P)|)&lt;/math&gt; is the size of the shortest SCS (longest LCS) of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;.
[[10.9|Solution]]


:10.10. Suppose you are given &lt;math&gt;n&lt;/math&gt; poker chips stacked in two stacks, where the edges of all chips can be seen. Each chip is one of three colors. A turn consists of choosing a color and removing all chips of that color from the tops of the stacks. The goal is to minimize the number of turns until the chips are gone. 
:For example, consider the stacks &lt;math&gt;(RRGG, GBBB)&lt;/math&gt;. Playing red, green, and then blue suffices to clear the stacks in three moves. Give an &lt;math&gt;O(n^2)&lt;/math&gt; dynamic programming algorithm to find the best strategy for a given pair of chip piles.

===Greedy Algorithms===

:[[10.11]]. Let &lt;math&gt;P_1, P_2, . . . , P_n&lt;/math&gt; be &lt;math&gt;n&lt;/math&gt; programs to be stored on a disk with capacity &lt;math&gt;D&lt;/math&gt; megabytes. Program &lt;math&gt;P_i&lt;/math&gt; requires &lt;math&gt;s_i&lt;/math&gt; megabytes of storage. We cannot store them all because &lt;math&gt;D &lt; \sum_{i=1}^n s_i &lt;/math&gt;
:(a) Does a greedy algorithm that selects programs in order of non-decreasing &lt;math&gt;s_i&lt;/math&gt; maximize the number of programs held on the disk? Prove or give a counter-example.
:(b) Does a greedy algorithm that selects programs in order of non-increasing &lt;math&gt;s_i&lt;/math&gt; use as much of the capacity of the disk as possible? Prove or give a counter-example.
[[10.11|Solution]]


:10.12. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We seek an algorithm to make change of &lt;math&gt;n&lt;/math&gt; units using the minimum number of this country’s coins.
:(a) The greedy algorithm repeatedly selects the biggest coin no bigger than the amount to be changed and repeats until it is zero. Show that the greedy algorithm does not always use the minimum number of coins in a country whose denominations are {1, 6, 10}.
:(b) Give an efficient algorithm that correctly determines the minimum number of coins needed to make change of &lt;math&gt;n&lt;/math&gt; units using denominations &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt;. Analyze its running time.


:[[10.13]]. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We want to count how many distinct ways &lt;math&gt;C(n)&lt;/math&gt; there are to make change of &lt;math&gt;n&lt;/math&gt; units. For example, in a country whose denominations are {1, 6, 10}, &lt;math&gt;C(5) = 1&lt;/math&gt;, &lt;math&gt;C(6)&lt;/math&gt; to &lt;math&gt;C(9) = 2&lt;/math&gt;, &lt;math&gt;C(10) = 3&lt;/math&gt;, and &lt;math&gt;C(12) = 4&lt;/math&gt;.
:(a) How many ways are there to make change of 20 units from {1, 6, 10}?
:(b) Give an efficient algorithm to compute &lt;math&gt;C(n)&lt;/math&gt;, and analyze its complexity. (Hint: think in terms of computing &lt;math&gt;C(n, d)&lt;/math&gt;, the number of ways to make change of &lt;math&gt;n&lt;/math&gt; units with highest denomination &lt;math&gt;d&lt;/math&gt;. Be careful to avoid overcounting.)
[[10.13|Solution]]


:10.14. In the single-processor scheduling problem, we are given a set of &lt;math&gt;n&lt;/math&gt; jobs &lt;math&gt;J&lt;/math&gt;. Each job &lt;math&gt;i&lt;/math&gt; has a processing time &lt;math&gt;t_i&lt;/math&gt;, and a deadline &lt;math&gt;d_i&lt;/math&gt;. A feasible schedule is a permutation of the jobs such that when the jobs are performed in that order, every job is finished before its deadline. The greedy algorithm for single-processor scheduling selects the job with the earliest deadline first.
:Show that if a feasible schedule exists, then the schedule produced by this greedy algorithm is feasible.

===Number Problems===

:[[10.15]]. You are given a rod of length &lt;math&gt;n&lt;/math&gt; inches and a table of prices obtainable for rod-pieces of size &lt;math&gt;n&lt;/math&gt; or smaller. Give an efficient algorithm to find the maximum value obtainable by cutting up the rod and selling the pieces. For example, if &lt;math&gt;n=8&lt;/math&gt; and the values of different pieces are:
&lt;center&gt;
\begin{array}{|C|rrrrrrrr} length &amp; 1 &amp; 2 &amp; 3 &amp; 4 &amp; 5 &amp; 6 &amp; 7 &amp; 8 \\
\hline
price &amp; 1 &amp; 5 &amp; 8 &amp; 9 &amp; 10 &amp; 17 &amp;17 &amp; 20 \\
\end{array}
&lt;/center&gt;
:then the maximum obtainable value is 22, by cutting into pieces of lengths 2 and 6.
[[10.15|Solution]]


:10.16. Your boss has written an arithmetic expression of n terms to compute your annual bonus, but permits you to parenthesize it however you wish. Give an efficient algorithm to design the parenthesization to maximize the value. For the expression:
&lt;center&gt;&lt;math&gt;6 + 2 * 0 - 4&lt;/math&gt;&lt;/center&gt;
:there exist parenthesizations with values ranging from −32 to 2.


:[[10.17]]. Given a positive integer &lt;math&gt;n&lt;/math&gt;, find an efficient algorithm to compute the smallest number of perfect squares (e.g. 1, 4, 9, 16, . . .) that sum to &lt;math&gt;n&lt;/math&gt;. What is the running time of your algorithm?
[[10.17|Solution]]


:10.18. Given an array &lt;math&gt;A&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find an efficient algorithm to compute the largest sum of a continuous run. For &lt;math&gt;A = [-3, 2, 7, -3, 4, -2, 0, 1]&lt;/math&gt;, the largest such sum is 10, from the second through fifth positions.


:[[10.19]]. Two drivers have to divide up &lt;math&gt;m&lt;/math&gt; suitcases between them, where the weight of the &lt;math&gt;ith&lt;/math&gt; suitcase is &lt;math&gt;w_i&lt;/math&gt;. Give an efficient algorithm to divide up the loads so the two drivers carry equal weight, if possible.
[[10.19|Solution]]


:10.20. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = {s_1, s_2, . . . , s_n}&lt;/math&gt;, and a given target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; that adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, within &lt;math&gt;S = {1, 2, 5, 9, 10}&lt;/math&gt; there is a subset that adds up to &lt;math&gt;T = 22&lt;/math&gt; but not &lt;math&gt;T = 23&lt;/math&gt;.
:Give a dynamic programming algorithm for knapsack that runs in &lt;math&gt;O(nT)&lt;/math&gt; time.


:[[10.21]]. The integer partition takes a set of positive integers &lt;math&gt;S = {s_1, . . . , s_n}&lt;/math&gt; and seeks a subset &lt;math&gt;I \subset S&lt;/math&gt; such that
&lt;center&gt;&lt;math&gt; \sum_{i \in I} s_i = \sum_{i \notin I} s_i&lt;/math&gt;&lt;/center&gt;
:Let &lt;math&gt; \sum_{i \in S} s_i = M &lt;/math&gt;. Give an &lt;math&gt;O(nM)&lt;/math&gt; dynamic programming algorithm to solve the integer partition problem.
[[10.21|Solution]]


:10.22. Assume that there are n numbers (some possibly negative) on a circle, and we wish to find the maximum contiguous sum along an arc of the circle. Give an efficient algorithm for solving this problem.


:[[10.23]]. A certain string processing language allows the programmer to break a string into two pieces. It costs &lt;math&gt;n&lt;/math&gt; units of time to break a string of &lt;math&gt;n&lt;/math&gt; characters into two pieces, since this involves copying the old string. A programmer wants to break a string into many pieces, and the order in which the breaks are made can affect the total amount of time used. For example, suppose we wish to break a 20-character string after characters 3, 8, and 10. If the breaks are made in left-to-right order, then the first break costs 20 units of time, the second break costs 17 units of time, and the third break costs 12 units of time, for a total of 49 units. If the breaks are made in right-to-left order, the first break costs 20 units of time, the second break costs 10 units of time, and the third break costs 8 units of time, for a total of only 38 units.
:Give a dynamic programming algorithm that takes a list of character positions after which to break and determines the cheapest break cost in &lt;math&gt;O(n^3)&lt;/math&gt; time.
[[10.23|Solution]]


:10.24. Consider the following data compression technique. We have a table of &lt;math&gt;m&lt;/math&gt; text strings, each at most &lt;math&gt;k&lt;/math&gt; in length. We want to encode a data string &lt;math&gt;D&lt;/math&gt; of length &lt;math&gt;n&lt;/math&gt; using as few text strings as possible. For example, if our table contains &lt;math&gt;(a,ba,abab,b)&lt;/math&gt; and the data string is &lt;math&gt;bababbaababa&lt;/math&gt;, the best way to encode it is &lt;math&gt;(b,abab,ba,abab,a)-a&lt;/math&gt; total of five code words. Give an &lt;math&gt;O(nmk)&lt;/math&gt; algorithm to find the length of the best encoding. You may assume that every string has at least one encoding in terms of the table.


:[[10.25]]. The traditional world chess championship is a match of 24 games. The current champion retains the title in case the match is a tie. Each game ends in a win, loss, or draw (tie) where wins count as 1, losses as 0, and draws as &lt;math&gt;1/2&lt;/math&gt;. The players take turns playing white and black. White plays first and so has an advantage. The champion plays white in the first game. The champ has probabilities &lt;math&gt;w_w&lt;/math&gt;, &lt;math&gt;w_d&lt;/math&gt;, and &lt;math&gt;w_l&lt;/math&gt; of winning, drawing, and losing playing white, and has probabilities &lt;math&gt;b_w&lt;/math&gt;, &lt;math&gt;b_d&lt;/math&gt;, and &lt;math&gt;b_l&lt;/math&gt; of winning, drawing, and losing playing black.
:(a) Write a recurrence for the probability that the champion retains the title. Assume that there are &lt;math&gt;g&lt;/math&gt; games left to play in the match and that the champion needs to get &lt;math&gt;i&lt;/math&gt; points (which may be a multiple of &lt;math&gt;1/2&lt;/math&gt;).
:(b) Based on your recurrence, give a dynamic programming algorithm to calculate the champion’s probability of retaining the title.
:(c) Analyze its running time for an &lt;math&gt;n&lt;/math&gt; game match.
[[10.125|Solution]]


:10.26. Eggs break when dropped from great enough height. Specifically, there must be a floor &lt;math&gt;f&lt;/math&gt; in any sufficiently tall building such that an egg dropped from the &lt;math&gt;f&lt;/math&gt;th floor breaks, but one dropped from the &lt;math&gt;(f - 1)&lt;/math&gt;st floor will not. If the egg always breaks, then &lt;math&gt;f = 1&lt;/math&gt;. If the egg never breaks, then &lt;math&gt;f = n + 1&lt;/math&gt;. 
:You seek to find the critical floor &lt;math&gt;f&lt;/math&gt; using an &lt;math&gt;n-floor&lt;/math&gt; building. The only operation you can perform is to drop an egg off some floor and see what happens. You start out with &lt;math&gt;k&lt;/math&gt; eggs, and seek to make as few drops as possible. Broken eggs cannot be reused. Let &lt;math&gt;E(k, n)&lt;/math&gt; be the minimum number of egg drops that will always suffice.
:(a) Show that &lt;math&gt;E(1, n) = n&lt;/math&gt;.
:(b) Show that &lt;math&gt;E(k, n) = \Theta (n^{1/k})&lt;/math&gt;.
:(c) Find a recurrence for &lt;math&gt;E(k, n)&lt;/math&gt;. What is the running time of the dynamic program to find &lt;math&gt;E(k, n)&lt;/math&gt;?

===Graphing Problem===

:[[10.27]]. Consider a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. 
:Unfortunately, the city has bad neighborhoods, whose intersections we do not want to walk in. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is in a neighborhood to avoid.
:(a) Give an example of the contents of bad such that there is no path across the grid avoiding bad neighborhoods.
:(b) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find a path across the grid that avoids bad neighborhoods.
:(c) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find the shortest path across the grid that avoids bad neighborhoods. You may assume that all blocks are of equal length. For partial credit, give an &lt;math&gt;O(X^2Y^2)&lt;/math&gt; algorithm.
[[10.27|Solution]]


:10.28. Consider the same situation as the previous problem. We have a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is somewhere we want to avoid.
:If there were no bad neighborhoods to contend with, the shortest path across the grid would have length &lt;math&gt;(X - 1) + (Y - 1)&lt;/math&gt; blocks, and indeed there would be many such paths across the grid. Each path would consist of only rightward and downward moves.
:Give an algorithm that takes the array bad and returns the number of safe paths of length &lt;math&gt;X + Y - 2&lt;/math&gt;. For full credit, your algorithm must run in &lt;math&gt;O(XY)&lt;/math&gt;.


:[[10.29]]. You seek to create a stack out of &lt;math&gt;n&lt;/math&gt; boxes, where box &lt;math&gt;i&lt;/math&gt; has width &lt;math&gt;w_i&lt;/math&gt;, height &lt;math&gt;h_i&lt;/math&gt;, and depth &lt;math&gt;d_i&lt;/math&gt;. The boxes cannot be rotated, and can only be stacked on top of one another when each box in the stack is strictly larger than the box above it in width, height, and depth. Give an efficient algorithm to construct the tallest possible stack, where the height is the sum of the heights of each box in the stack.
[[10.29|Solution]]

===Design Problems===

:10.30. Consider the problem of storing &lt;math&gt;n&lt;/math&gt; books on shelves in a library. The order of the books is fixed by the cataloging system and so cannot be rearranged. Therefore, we can speak of a book &lt;math&gt;b_i&lt;/math&gt;, where &lt;math&gt;1 \leq i \leq n&lt;/math&gt;, that has a thickness &lt;math&gt;t_i&lt;/math&gt; and height &lt;math&gt;h_i&lt;/math&gt;. The length of each bookshelf at this library is &lt;math&gt;L&lt;/math&gt;.
:Suppose all the books have the same height &lt;math&gt;h&lt;/math&gt; (i.e., &lt;math&gt;h = h_i&lt;/math&gt; for all &lt;math&gt;i&lt;/math&gt;) and the shelves are all separated by a distance greater than &lt;math&gt;h&lt;/math&gt;, so any book fits on any shelf. The greedy algorithm would fill the first shelf with as many books as we can until we get the smallest &lt;math&gt;i&lt;/math&gt; such that &lt;math&gt;b_i&lt;/math&gt; does not fit, and then repeat with subsequent shelves. Show that the greedy algorithm always finds the book placement that uses the minimum number of shelves, and analyze its time complexity.


:[[10.31]]. This is a generalization of the previous problem. Now consider the case where the height of the books is not constant, but we have the freedom to adjust the height of each shelf to that of the tallest book on the shelf. Here the cost of a particular layout is the sum of the heights of the largest book on each shelf.
:#Give an example to show that the greedy algorithm of stuffing each shelf as full as possible does not always give the minimum overall height.
:#Give an algorithm for this problem, and analyze its time complexity. (Hint: use dynamic programming.)
[[10.31|Solution]]


:10.32. Consider a linear keyboard of lowercase letters and numbers, where the left-most 26 keys are the letters A–Z in order, followed by the digits 0–9 in order, followed by the 30 punctuation characters in a prescribed order, and ended on a blank. Assume you start with your left index finger on the “A” and your right index finger on the blank.
:Give a dynamic programming algorithm that finds the most efficient way to type a given text of length &lt;math&gt;n&lt;/math&gt;, in terms of minimizing total movement of the fingers involved. For the text &lt;math&gt;ABABABAB . . . ABAB&lt;/math&gt;, this would involve shifting both fingers all the way to the left side of the keyboard. Analyze the complexity of your algorithm as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;, the number of keys on the keyboard.


:[[10.33]]. You have come back from the future with an array &lt;math&gt;G&lt;/math&gt;, where &lt;math&gt;G[i]&lt;/math&gt; tells you the price of Google stock &lt;math&gt;i&lt;/math&gt; days from now, for &lt;math&gt;1 \leq i \leq n&lt;/math&gt;. You seek to use this information to maximize your profit, but are only permitted to complete at most one transaction (i.e. either buy one or sell one share of the stock) per day. Design an efficient algorithm to construct the buy–sell sequence to maximize your profit. Note that you cannot sell a share unless you currently own one.
[[10.33|Solution]]


:10.34. You are given a string of &lt;math&gt;n&lt;/math&gt; characters &lt;math&gt;S = s_1 . . . s_n&lt;/math&gt;, which you believe to be a compressed text document in which all spaces have been removed, like '''itwasthebestoftimes'''.
:(a) You seek to reconstruct the document using a dictionary, which is available in the form of a Boolean function &lt;math&gt;dict(w)&lt;/math&gt;, where &lt;math&gt;dict(w)&lt;/math&gt; is true iff string &lt;math&gt;w&lt;/math&gt; is a valid word in the language. Give an &lt;math&gt;O(n^2)&lt;/math&gt; algorithm to determine whether string &lt;math&gt;S&lt;/math&gt; can be reconstituted as a sequence of valid words, assuming calls to &lt;math&gt;dict(w &lt;/math&gt; take unit time.
:(b) Now assume you are given the dictionary as a set of &lt;math&gt;m&lt;/math&gt; words each of length at most l. Give an efficient algorithm to determine whether string &lt;math&gt;S&lt;/math&gt; can be reconstituted as a sequence of valid words, and its running time.


:[[10.35]]. Consider the following two-player game, where you seek to get the biggest score. You start with an n-digit integer &lt;math&gt;N&lt;/math&gt;. With each move, you get to take either the first digit or the last digit from what is left of &lt;math&gt;N&lt;/math&gt;, and add that to your score, with your opponent then doing the same thing to the now smaller number. You continue taking turns removing digits until none are left. Give an efficient algorithm that finds the best possible score that the first player can get for a given digit string &lt;math&gt;N&lt;/math&gt;, assuming the second player is as smart as can be.
[[10.35|Solution]]


:10.36. Given an array of &lt;math&gt;n&lt;/math&gt; real numbers, consider the problem of finding the maximum sum in any contiguous subarray of the input. For example, in the array
&lt;center&gt;&lt;math&gt;[31, -41, 59, 26, -53, 58, 97, -93, -23, 84]&lt;/math&gt;&lt;/center&gt;
:the maximum is achieved by summing the third through seventh elements, where 59 + 26 + (−53) + 58 + 97 = 187. When all numbers are positive, the entire array is the answer, while when all numbers are negative, the empty array maximizes the total at 0.
#Give a simple and clear &lt;math&gt; \Theta (n^2)&lt;/math&gt;-time algorithm to find the maximum contiguous subarray.
#Now give a &lt;math&gt;\Theta (n)&lt;/math&gt;-time dynamic programming algorithm for this problem. To get partial credit, you may instead give a correct &lt;math&gt;O(n log n)&lt;/math&gt; divide-and-conquer algorithm.


:[[10.37]]


:10.38. Let α and β be constants. Assume that it costs α to go left in a binary search tree, and β to go right. Devise an algorithm that builds a tree with optimal expected query cost, given keys &lt;math&gt;k_1, . . . , k_n&lt;/math&gt; and the probabilities that each will be searched &lt;math&gt;p_1, . . . , p_n&lt;/math&gt;.

===Interview Problems===

:[[10.39]]


:10.40


:[[10.41]]


Back to [[Chapter List]]</text>
      <sha1>67mbji0i0hg2z9no8pw4lk2gabdndz8</sha1>
    </revision>
    <revision>
      <id>222</id>
      <parentid>221</parentid>
      <timestamp>2020-09-13T20:48:32Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Interview Problems */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23678">=Dynamic Programming=

===Elementary Recurrences===

:[[10.1]]. Up to &lt;math&gt;k&lt;/math&gt; steps in a single bound! A child is running up a staircase with &lt;math&gt;n&lt;/math&gt; steps and can hop between 1 and &lt;math&gt;k&lt;/math&gt; steps at a time. Design an algorithm to count how many possible ways the child can run up the stairs, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. What is the running time of your algorithm?
[[10.1|Solution]]


:10.2. Imagine you are a professional thief who plans to rob houses along a street of &lt;math&gt;n&lt;/math&gt; homes. You know the loot at house &lt;math&gt;i&lt;/math&gt; is worth &lt;math&gt;m_i&lt;/math&gt;, for &lt;math&gt;1 \le i \le n&lt;/math&gt;, but you cannot rob neighboring houses because their connected security systems will automatically contact the police if two adjacent houses are broken into. Give an efficient algorithm to determine the maximum amount of money you can steal without alerting the police.


:[[10.3]]. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible mixes (1s,2s,3s) of scoring add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are four possible solutions: (5, 0, 0), (2, 0, 1), (1, 2, 0), and (0, 1, 1).
[[10.3|Solution]]


:10.4. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible scoring sequences add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are thirteen possible sequences, including 1-2-1-1, 3-2, and 1-1-1-1-1.


:[[10.5]]. Given an &lt;math&gt;s * t&lt;/math&gt; grid filled with non-negative numbers, find a path from top left to bottom right that minimizes the sum of all numbers along its path. You can only move either down or right at any point in time.
::(a) Give a solution based on Dijkstra’s algorithm. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
::(b) Give a solution based on dynamic programming. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
[[10.5|Solution]]

===Edit Distance===

:10.6. Typists often make transposition errors exchanging neighboring characters, such as typing “setve” for “steve.” This requires two substitutions to fix under the conventional definition of edit distance.
:Incorporate a swap operation into our edit distance function, so that such neighboring transposition errors can be fixed at the cost of one operation.


:[[10.7]]. Suppose you are given three strings of characters: &lt;math&gt;X&lt;/math&gt;, &lt;math&gt;Y&lt;/math&gt;, and &lt;math&gt;Z&lt;/math&gt;, where &lt;math&gt;|X| = n&lt;/math&gt;, &lt;math&gt;|Y| = m&lt;/math&gt;, and &lt;math&gt;|Z| = n + m&lt;/math&gt;. &lt;math&gt;Z&lt;/math&gt; is said to be a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; iff &lt;math&gt;Z&lt;/math&gt; can be formed by interleaving the characters from &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; in a way that maintains the left-to-right ordering of the characters from each string. 
:(a) Show that cchocohilaptes is a shuffle of chocolate and chips, but chocochilatspe is not.
:(b) Give an efficient dynamic programming algorithm that determines whether &lt;math&gt;Z&lt;/math&gt; is a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt;. (Hint: the values of the dynamic programming matrix you construct should be Boolean, not numeric.)
[[10.7|Solution]]


:10.8. The longest common substring (not subsequence) of two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; is the longest string that appears as a run of consecutive letters in both strings. For example, the longest common substring of photograph and tomography is ograph.
:(a) Let &lt;math&gt;n = |X|&lt;/math&gt; and &lt;math&gt;m = |Y|&lt;/math&gt;. Give a &lt;math&gt;\Theta (nm)&lt;/math&gt; dynamic programming algorithm for longest common substring based on the longest common subsequence/edit distance algorithm.
:(b) Give a simpler &lt;math&gt;\Theta (nm)&lt;/math&gt; algorithm that does not rely on dynamic programming.


:[[10.9]]. The ''longest common subsequence (LCS)'' of two sequences &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the longest sequence &lt;math&gt;L&lt;/math&gt; such that &lt;math&gt;L&lt;/math&gt; is a subsequence of both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;. The ''shortest common supersequence (SCS)'' of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the smallest sequence &lt;math&gt;L&lt;/math&gt; such that both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; are a subsequence of &lt;math&gt;L&lt;/math&gt;.
:(a) Give efficient algorithms to find the LCS and SCS of two given sequences.
:(b) Let &lt;math&gt;d(T, P)&lt;/math&gt; be the minimum edit distance between &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; when no substitutions are allowed (i.e., the only changes are character insertion and deletion). Prove that &lt;math&gt;d(T, P) = |SCS(T, P)| - |LCS(T, P)|&lt;/math&gt; where &lt;math&gt;|SCS(T, P)| (|LCS(T, P)|)&lt;/math&gt; is the size of the shortest SCS (longest LCS) of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;.
[[10.9|Solution]]


:10.10. Suppose you are given &lt;math&gt;n&lt;/math&gt; poker chips stacked in two stacks, where the edges of all chips can be seen. Each chip is one of three colors. A turn consists of choosing a color and removing all chips of that color from the tops of the stacks. The goal is to minimize the number of turns until the chips are gone. 
:For example, consider the stacks &lt;math&gt;(RRGG, GBBB)&lt;/math&gt;. Playing red, green, and then blue suffices to clear the stacks in three moves. Give an &lt;math&gt;O(n^2)&lt;/math&gt; dynamic programming algorithm to find the best strategy for a given pair of chip piles.

===Greedy Algorithms===

:[[10.11]]. Let &lt;math&gt;P_1, P_2, . . . , P_n&lt;/math&gt; be &lt;math&gt;n&lt;/math&gt; programs to be stored on a disk with capacity &lt;math&gt;D&lt;/math&gt; megabytes. Program &lt;math&gt;P_i&lt;/math&gt; requires &lt;math&gt;s_i&lt;/math&gt; megabytes of storage. We cannot store them all because &lt;math&gt;D &lt; \sum_{i=1}^n s_i &lt;/math&gt;
:(a) Does a greedy algorithm that selects programs in order of non-decreasing &lt;math&gt;s_i&lt;/math&gt; maximize the number of programs held on the disk? Prove or give a counter-example.
:(b) Does a greedy algorithm that selects programs in order of non-increasing &lt;math&gt;s_i&lt;/math&gt; use as much of the capacity of the disk as possible? Prove or give a counter-example.
[[10.11|Solution]]


:10.12. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We seek an algorithm to make change of &lt;math&gt;n&lt;/math&gt; units using the minimum number of this country’s coins.
:(a) The greedy algorithm repeatedly selects the biggest coin no bigger than the amount to be changed and repeats until it is zero. Show that the greedy algorithm does not always use the minimum number of coins in a country whose denominations are {1, 6, 10}.
:(b) Give an efficient algorithm that correctly determines the minimum number of coins needed to make change of &lt;math&gt;n&lt;/math&gt; units using denominations &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt;. Analyze its running time.


:[[10.13]]. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We want to count how many distinct ways &lt;math&gt;C(n)&lt;/math&gt; there are to make change of &lt;math&gt;n&lt;/math&gt; units. For example, in a country whose denominations are {1, 6, 10}, &lt;math&gt;C(5) = 1&lt;/math&gt;, &lt;math&gt;C(6)&lt;/math&gt; to &lt;math&gt;C(9) = 2&lt;/math&gt;, &lt;math&gt;C(10) = 3&lt;/math&gt;, and &lt;math&gt;C(12) = 4&lt;/math&gt;.
:(a) How many ways are there to make change of 20 units from {1, 6, 10}?
:(b) Give an efficient algorithm to compute &lt;math&gt;C(n)&lt;/math&gt;, and analyze its complexity. (Hint: think in terms of computing &lt;math&gt;C(n, d)&lt;/math&gt;, the number of ways to make change of &lt;math&gt;n&lt;/math&gt; units with highest denomination &lt;math&gt;d&lt;/math&gt;. Be careful to avoid overcounting.)
[[10.13|Solution]]


:10.14. In the single-processor scheduling problem, we are given a set of &lt;math&gt;n&lt;/math&gt; jobs &lt;math&gt;J&lt;/math&gt;. Each job &lt;math&gt;i&lt;/math&gt; has a processing time &lt;math&gt;t_i&lt;/math&gt;, and a deadline &lt;math&gt;d_i&lt;/math&gt;. A feasible schedule is a permutation of the jobs such that when the jobs are performed in that order, every job is finished before its deadline. The greedy algorithm for single-processor scheduling selects the job with the earliest deadline first.
:Show that if a feasible schedule exists, then the schedule produced by this greedy algorithm is feasible.

===Number Problems===

:[[10.15]]. You are given a rod of length &lt;math&gt;n&lt;/math&gt; inches and a table of prices obtainable for rod-pieces of size &lt;math&gt;n&lt;/math&gt; or smaller. Give an efficient algorithm to find the maximum value obtainable by cutting up the rod and selling the pieces. For example, if &lt;math&gt;n=8&lt;/math&gt; and the values of different pieces are:
&lt;center&gt;
\begin{array}{|C|rrrrrrrr} length &amp; 1 &amp; 2 &amp; 3 &amp; 4 &amp; 5 &amp; 6 &amp; 7 &amp; 8 \\
\hline
price &amp; 1 &amp; 5 &amp; 8 &amp; 9 &amp; 10 &amp; 17 &amp;17 &amp; 20 \\
\end{array}
&lt;/center&gt;
:then the maximum obtainable value is 22, by cutting into pieces of lengths 2 and 6.
[[10.15|Solution]]


:10.16. Your boss has written an arithmetic expression of n terms to compute your annual bonus, but permits you to parenthesize it however you wish. Give an efficient algorithm to design the parenthesization to maximize the value. For the expression:
&lt;center&gt;&lt;math&gt;6 + 2 * 0 - 4&lt;/math&gt;&lt;/center&gt;
:there exist parenthesizations with values ranging from −32 to 2.


:[[10.17]]. Given a positive integer &lt;math&gt;n&lt;/math&gt;, find an efficient algorithm to compute the smallest number of perfect squares (e.g. 1, 4, 9, 16, . . .) that sum to &lt;math&gt;n&lt;/math&gt;. What is the running time of your algorithm?
[[10.17|Solution]]


:10.18. Given an array &lt;math&gt;A&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find an efficient algorithm to compute the largest sum of a continuous run. For &lt;math&gt;A = [-3, 2, 7, -3, 4, -2, 0, 1]&lt;/math&gt;, the largest such sum is 10, from the second through fifth positions.


:[[10.19]]. Two drivers have to divide up &lt;math&gt;m&lt;/math&gt; suitcases between them, where the weight of the &lt;math&gt;ith&lt;/math&gt; suitcase is &lt;math&gt;w_i&lt;/math&gt;. Give an efficient algorithm to divide up the loads so the two drivers carry equal weight, if possible.
[[10.19|Solution]]


:10.20. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = {s_1, s_2, . . . , s_n}&lt;/math&gt;, and a given target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; that adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, within &lt;math&gt;S = {1, 2, 5, 9, 10}&lt;/math&gt; there is a subset that adds up to &lt;math&gt;T = 22&lt;/math&gt; but not &lt;math&gt;T = 23&lt;/math&gt;.
:Give a dynamic programming algorithm for knapsack that runs in &lt;math&gt;O(nT)&lt;/math&gt; time.


:[[10.21]]. The integer partition takes a set of positive integers &lt;math&gt;S = {s_1, . . . , s_n}&lt;/math&gt; and seeks a subset &lt;math&gt;I \subset S&lt;/math&gt; such that
&lt;center&gt;&lt;math&gt; \sum_{i \in I} s_i = \sum_{i \notin I} s_i&lt;/math&gt;&lt;/center&gt;
:Let &lt;math&gt; \sum_{i \in S} s_i = M &lt;/math&gt;. Give an &lt;math&gt;O(nM)&lt;/math&gt; dynamic programming algorithm to solve the integer partition problem.
[[10.21|Solution]]


:10.22. Assume that there are n numbers (some possibly negative) on a circle, and we wish to find the maximum contiguous sum along an arc of the circle. Give an efficient algorithm for solving this problem.


:[[10.23]]. A certain string processing language allows the programmer to break a string into two pieces. It costs &lt;math&gt;n&lt;/math&gt; units of time to break a string of &lt;math&gt;n&lt;/math&gt; characters into two pieces, since this involves copying the old string. A programmer wants to break a string into many pieces, and the order in which the breaks are made can affect the total amount of time used. For example, suppose we wish to break a 20-character string after characters 3, 8, and 10. If the breaks are made in left-to-right order, then the first break costs 20 units of time, the second break costs 17 units of time, and the third break costs 12 units of time, for a total of 49 units. If the breaks are made in right-to-left order, the first break costs 20 units of time, the second break costs 10 units of time, and the third break costs 8 units of time, for a total of only 38 units.
:Give a dynamic programming algorithm that takes a list of character positions after which to break and determines the cheapest break cost in &lt;math&gt;O(n^3)&lt;/math&gt; time.
[[10.23|Solution]]


:10.24. Consider the following data compression technique. We have a table of &lt;math&gt;m&lt;/math&gt; text strings, each at most &lt;math&gt;k&lt;/math&gt; in length. We want to encode a data string &lt;math&gt;D&lt;/math&gt; of length &lt;math&gt;n&lt;/math&gt; using as few text strings as possible. For example, if our table contains &lt;math&gt;(a,ba,abab,b)&lt;/math&gt; and the data string is &lt;math&gt;bababbaababa&lt;/math&gt;, the best way to encode it is &lt;math&gt;(b,abab,ba,abab,a)-a&lt;/math&gt; total of five code words. Give an &lt;math&gt;O(nmk)&lt;/math&gt; algorithm to find the length of the best encoding. You may assume that every string has at least one encoding in terms of the table.


:[[10.25]]. The traditional world chess championship is a match of 24 games. The current champion retains the title in case the match is a tie. Each game ends in a win, loss, or draw (tie) where wins count as 1, losses as 0, and draws as &lt;math&gt;1/2&lt;/math&gt;. The players take turns playing white and black. White plays first and so has an advantage. The champion plays white in the first game. The champ has probabilities &lt;math&gt;w_w&lt;/math&gt;, &lt;math&gt;w_d&lt;/math&gt;, and &lt;math&gt;w_l&lt;/math&gt; of winning, drawing, and losing playing white, and has probabilities &lt;math&gt;b_w&lt;/math&gt;, &lt;math&gt;b_d&lt;/math&gt;, and &lt;math&gt;b_l&lt;/math&gt; of winning, drawing, and losing playing black.
:(a) Write a recurrence for the probability that the champion retains the title. Assume that there are &lt;math&gt;g&lt;/math&gt; games left to play in the match and that the champion needs to get &lt;math&gt;i&lt;/math&gt; points (which may be a multiple of &lt;math&gt;1/2&lt;/math&gt;).
:(b) Based on your recurrence, give a dynamic programming algorithm to calculate the champion’s probability of retaining the title.
:(c) Analyze its running time for an &lt;math&gt;n&lt;/math&gt; game match.
[[10.125|Solution]]


:10.26. Eggs break when dropped from great enough height. Specifically, there must be a floor &lt;math&gt;f&lt;/math&gt; in any sufficiently tall building such that an egg dropped from the &lt;math&gt;f&lt;/math&gt;th floor breaks, but one dropped from the &lt;math&gt;(f - 1)&lt;/math&gt;st floor will not. If the egg always breaks, then &lt;math&gt;f = 1&lt;/math&gt;. If the egg never breaks, then &lt;math&gt;f = n + 1&lt;/math&gt;. 
:You seek to find the critical floor &lt;math&gt;f&lt;/math&gt; using an &lt;math&gt;n-floor&lt;/math&gt; building. The only operation you can perform is to drop an egg off some floor and see what happens. You start out with &lt;math&gt;k&lt;/math&gt; eggs, and seek to make as few drops as possible. Broken eggs cannot be reused. Let &lt;math&gt;E(k, n)&lt;/math&gt; be the minimum number of egg drops that will always suffice.
:(a) Show that &lt;math&gt;E(1, n) = n&lt;/math&gt;.
:(b) Show that &lt;math&gt;E(k, n) = \Theta (n^{1/k})&lt;/math&gt;.
:(c) Find a recurrence for &lt;math&gt;E(k, n)&lt;/math&gt;. What is the running time of the dynamic program to find &lt;math&gt;E(k, n)&lt;/math&gt;?

===Graphing Problem===

:[[10.27]]. Consider a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. 
:Unfortunately, the city has bad neighborhoods, whose intersections we do not want to walk in. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is in a neighborhood to avoid.
:(a) Give an example of the contents of bad such that there is no path across the grid avoiding bad neighborhoods.
:(b) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find a path across the grid that avoids bad neighborhoods.
:(c) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find the shortest path across the grid that avoids bad neighborhoods. You may assume that all blocks are of equal length. For partial credit, give an &lt;math&gt;O(X^2Y^2)&lt;/math&gt; algorithm.
[[10.27|Solution]]


:10.28. Consider the same situation as the previous problem. We have a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is somewhere we want to avoid.
:If there were no bad neighborhoods to contend with, the shortest path across the grid would have length &lt;math&gt;(X - 1) + (Y - 1)&lt;/math&gt; blocks, and indeed there would be many such paths across the grid. Each path would consist of only rightward and downward moves.
:Give an algorithm that takes the array bad and returns the number of safe paths of length &lt;math&gt;X + Y - 2&lt;/math&gt;. For full credit, your algorithm must run in &lt;math&gt;O(XY)&lt;/math&gt;.


:[[10.29]]. You seek to create a stack out of &lt;math&gt;n&lt;/math&gt; boxes, where box &lt;math&gt;i&lt;/math&gt; has width &lt;math&gt;w_i&lt;/math&gt;, height &lt;math&gt;h_i&lt;/math&gt;, and depth &lt;math&gt;d_i&lt;/math&gt;. The boxes cannot be rotated, and can only be stacked on top of one another when each box in the stack is strictly larger than the box above it in width, height, and depth. Give an efficient algorithm to construct the tallest possible stack, where the height is the sum of the heights of each box in the stack.
[[10.29|Solution]]

===Design Problems===

:10.30. Consider the problem of storing &lt;math&gt;n&lt;/math&gt; books on shelves in a library. The order of the books is fixed by the cataloging system and so cannot be rearranged. Therefore, we can speak of a book &lt;math&gt;b_i&lt;/math&gt;, where &lt;math&gt;1 \leq i \leq n&lt;/math&gt;, that has a thickness &lt;math&gt;t_i&lt;/math&gt; and height &lt;math&gt;h_i&lt;/math&gt;. The length of each bookshelf at this library is &lt;math&gt;L&lt;/math&gt;.
:Suppose all the books have the same height &lt;math&gt;h&lt;/math&gt; (i.e., &lt;math&gt;h = h_i&lt;/math&gt; for all &lt;math&gt;i&lt;/math&gt;) and the shelves are all separated by a distance greater than &lt;math&gt;h&lt;/math&gt;, so any book fits on any shelf. The greedy algorithm would fill the first shelf with as many books as we can until we get the smallest &lt;math&gt;i&lt;/math&gt; such that &lt;math&gt;b_i&lt;/math&gt; does not fit, and then repeat with subsequent shelves. Show that the greedy algorithm always finds the book placement that uses the minimum number of shelves, and analyze its time complexity.


:[[10.31]]. This is a generalization of the previous problem. Now consider the case where the height of the books is not constant, but we have the freedom to adjust the height of each shelf to that of the tallest book on the shelf. Here the cost of a particular layout is the sum of the heights of the largest book on each shelf.
:#Give an example to show that the greedy algorithm of stuffing each shelf as full as possible does not always give the minimum overall height.
:#Give an algorithm for this problem, and analyze its time complexity. (Hint: use dynamic programming.)
[[10.31|Solution]]


:10.32. Consider a linear keyboard of lowercase letters and numbers, where the left-most 26 keys are the letters A–Z in order, followed by the digits 0–9 in order, followed by the 30 punctuation characters in a prescribed order, and ended on a blank. Assume you start with your left index finger on the “A” and your right index finger on the blank.
:Give a dynamic programming algorithm that finds the most efficient way to type a given text of length &lt;math&gt;n&lt;/math&gt;, in terms of minimizing total movement of the fingers involved. For the text &lt;math&gt;ABABABAB . . . ABAB&lt;/math&gt;, this would involve shifting both fingers all the way to the left side of the keyboard. Analyze the complexity of your algorithm as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;, the number of keys on the keyboard.


:[[10.33]]. You have come back from the future with an array &lt;math&gt;G&lt;/math&gt;, where &lt;math&gt;G[i]&lt;/math&gt; tells you the price of Google stock &lt;math&gt;i&lt;/math&gt; days from now, for &lt;math&gt;1 \leq i \leq n&lt;/math&gt;. You seek to use this information to maximize your profit, but are only permitted to complete at most one transaction (i.e. either buy one or sell one share of the stock) per day. Design an efficient algorithm to construct the buy–sell sequence to maximize your profit. Note that you cannot sell a share unless you currently own one.
[[10.33|Solution]]


:10.34. You are given a string of &lt;math&gt;n&lt;/math&gt; characters &lt;math&gt;S = s_1 . . . s_n&lt;/math&gt;, which you believe to be a compressed text document in which all spaces have been removed, like '''itwasthebestoftimes'''.
:(a) You seek to reconstruct the document using a dictionary, which is available in the form of a Boolean function &lt;math&gt;dict(w)&lt;/math&gt;, where &lt;math&gt;dict(w)&lt;/math&gt; is true iff string &lt;math&gt;w&lt;/math&gt; is a valid word in the language. Give an &lt;math&gt;O(n^2)&lt;/math&gt; algorithm to determine whether string &lt;math&gt;S&lt;/math&gt; can be reconstituted as a sequence of valid words, assuming calls to &lt;math&gt;dict(w &lt;/math&gt; take unit time.
:(b) Now assume you are given the dictionary as a set of &lt;math&gt;m&lt;/math&gt; words each of length at most l. Give an efficient algorithm to determine whether string &lt;math&gt;S&lt;/math&gt; can be reconstituted as a sequence of valid words, and its running time.


:[[10.35]]. Consider the following two-player game, where you seek to get the biggest score. You start with an n-digit integer &lt;math&gt;N&lt;/math&gt;. With each move, you get to take either the first digit or the last digit from what is left of &lt;math&gt;N&lt;/math&gt;, and add that to your score, with your opponent then doing the same thing to the now smaller number. You continue taking turns removing digits until none are left. Give an efficient algorithm that finds the best possible score that the first player can get for a given digit string &lt;math&gt;N&lt;/math&gt;, assuming the second player is as smart as can be.
[[10.35|Solution]]


:10.36. Given an array of &lt;math&gt;n&lt;/math&gt; real numbers, consider the problem of finding the maximum sum in any contiguous subarray of the input. For example, in the array
&lt;center&gt;&lt;math&gt;[31, -41, 59, 26, -53, 58, 97, -93, -23, 84]&lt;/math&gt;&lt;/center&gt;
:the maximum is achieved by summing the third through seventh elements, where 59 + 26 + (−53) + 58 + 97 = 187. When all numbers are positive, the entire array is the answer, while when all numbers are negative, the empty array maximizes the total at 0.
#Give a simple and clear &lt;math&gt; \Theta (n^2)&lt;/math&gt;-time algorithm to find the maximum contiguous subarray.
#Now give a &lt;math&gt;\Theta (n)&lt;/math&gt;-time dynamic programming algorithm for this problem. To get partial credit, you may instead give a correct &lt;math&gt;O(n log n)&lt;/math&gt; divide-and-conquer algorithm.


:[[10.37]]


:10.38. Let α and β be constants. Assume that it costs α to go left in a binary search tree, and β to go right. Devise an algorithm that builds a tree with optimal expected query cost, given keys &lt;math&gt;k_1, . . . , k_n&lt;/math&gt; and the probabilities that each will be searched &lt;math&gt;p_1, . . . , p_n&lt;/math&gt;.

===Interview Problems===

:[[10.39]]. Given a set of coin denominations, find the minimum number of coins to make a certain amount of change.
[[10.39|Solution]]


:10.40. You are given an array of n numbers, each of which may be positive, negative, or zero. Give an efficient algorithm to identify the index positions &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; to obtain the maximum sum of the &lt;math&gt;i&lt;/math&gt;th through &lt;math&gt;j&lt;/math&gt;th numbers.


:[[10.41]]. Observe that when you cut a character out of a magazine, the character on the reverse side of the page is also removed. Give an algorithm to determine whether you can generate a given string by pasting cutouts from a given magazine. Assume that you are given a function that will identify the character and its position on the reverse side of the page for any given character position.


Back to [[Chapter List]]</text>
      <sha1>2g1gjkmhhvt16zczlj7tzo8tnm1sylz</sha1>
    </revision>
    <revision>
      <id>223</id>
      <parentid>222</parentid>
      <timestamp>2020-09-13T20:48:56Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Interview Problems */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23697">=Dynamic Programming=

===Elementary Recurrences===

:[[10.1]]. Up to &lt;math&gt;k&lt;/math&gt; steps in a single bound! A child is running up a staircase with &lt;math&gt;n&lt;/math&gt; steps and can hop between 1 and &lt;math&gt;k&lt;/math&gt; steps at a time. Design an algorithm to count how many possible ways the child can run up the stairs, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. What is the running time of your algorithm?
[[10.1|Solution]]


:10.2. Imagine you are a professional thief who plans to rob houses along a street of &lt;math&gt;n&lt;/math&gt; homes. You know the loot at house &lt;math&gt;i&lt;/math&gt; is worth &lt;math&gt;m_i&lt;/math&gt;, for &lt;math&gt;1 \le i \le n&lt;/math&gt;, but you cannot rob neighboring houses because their connected security systems will automatically contact the police if two adjacent houses are broken into. Give an efficient algorithm to determine the maximum amount of money you can steal without alerting the police.


:[[10.3]]. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible mixes (1s,2s,3s) of scoring add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are four possible solutions: (5, 0, 0), (2, 0, 1), (1, 2, 0), and (0, 1, 1).
[[10.3|Solution]]


:10.4. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible scoring sequences add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are thirteen possible sequences, including 1-2-1-1, 3-2, and 1-1-1-1-1.


:[[10.5]]. Given an &lt;math&gt;s * t&lt;/math&gt; grid filled with non-negative numbers, find a path from top left to bottom right that minimizes the sum of all numbers along its path. You can only move either down or right at any point in time.
::(a) Give a solution based on Dijkstra’s algorithm. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
::(b) Give a solution based on dynamic programming. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
[[10.5|Solution]]

===Edit Distance===

:10.6. Typists often make transposition errors exchanging neighboring characters, such as typing “setve” for “steve.” This requires two substitutions to fix under the conventional definition of edit distance.
:Incorporate a swap operation into our edit distance function, so that such neighboring transposition errors can be fixed at the cost of one operation.


:[[10.7]]. Suppose you are given three strings of characters: &lt;math&gt;X&lt;/math&gt;, &lt;math&gt;Y&lt;/math&gt;, and &lt;math&gt;Z&lt;/math&gt;, where &lt;math&gt;|X| = n&lt;/math&gt;, &lt;math&gt;|Y| = m&lt;/math&gt;, and &lt;math&gt;|Z| = n + m&lt;/math&gt;. &lt;math&gt;Z&lt;/math&gt; is said to be a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; iff &lt;math&gt;Z&lt;/math&gt; can be formed by interleaving the characters from &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; in a way that maintains the left-to-right ordering of the characters from each string. 
:(a) Show that cchocohilaptes is a shuffle of chocolate and chips, but chocochilatspe is not.
:(b) Give an efficient dynamic programming algorithm that determines whether &lt;math&gt;Z&lt;/math&gt; is a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt;. (Hint: the values of the dynamic programming matrix you construct should be Boolean, not numeric.)
[[10.7|Solution]]


:10.8. The longest common substring (not subsequence) of two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; is the longest string that appears as a run of consecutive letters in both strings. For example, the longest common substring of photograph and tomography is ograph.
:(a) Let &lt;math&gt;n = |X|&lt;/math&gt; and &lt;math&gt;m = |Y|&lt;/math&gt;. Give a &lt;math&gt;\Theta (nm)&lt;/math&gt; dynamic programming algorithm for longest common substring based on the longest common subsequence/edit distance algorithm.
:(b) Give a simpler &lt;math&gt;\Theta (nm)&lt;/math&gt; algorithm that does not rely on dynamic programming.


:[[10.9]]. The ''longest common subsequence (LCS)'' of two sequences &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the longest sequence &lt;math&gt;L&lt;/math&gt; such that &lt;math&gt;L&lt;/math&gt; is a subsequence of both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;. The ''shortest common supersequence (SCS)'' of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the smallest sequence &lt;math&gt;L&lt;/math&gt; such that both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; are a subsequence of &lt;math&gt;L&lt;/math&gt;.
:(a) Give efficient algorithms to find the LCS and SCS of two given sequences.
:(b) Let &lt;math&gt;d(T, P)&lt;/math&gt; be the minimum edit distance between &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; when no substitutions are allowed (i.e., the only changes are character insertion and deletion). Prove that &lt;math&gt;d(T, P) = |SCS(T, P)| - |LCS(T, P)|&lt;/math&gt; where &lt;math&gt;|SCS(T, P)| (|LCS(T, P)|)&lt;/math&gt; is the size of the shortest SCS (longest LCS) of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;.
[[10.9|Solution]]


:10.10. Suppose you are given &lt;math&gt;n&lt;/math&gt; poker chips stacked in two stacks, where the edges of all chips can be seen. Each chip is one of three colors. A turn consists of choosing a color and removing all chips of that color from the tops of the stacks. The goal is to minimize the number of turns until the chips are gone. 
:For example, consider the stacks &lt;math&gt;(RRGG, GBBB)&lt;/math&gt;. Playing red, green, and then blue suffices to clear the stacks in three moves. Give an &lt;math&gt;O(n^2)&lt;/math&gt; dynamic programming algorithm to find the best strategy for a given pair of chip piles.

===Greedy Algorithms===

:[[10.11]]. Let &lt;math&gt;P_1, P_2, . . . , P_n&lt;/math&gt; be &lt;math&gt;n&lt;/math&gt; programs to be stored on a disk with capacity &lt;math&gt;D&lt;/math&gt; megabytes. Program &lt;math&gt;P_i&lt;/math&gt; requires &lt;math&gt;s_i&lt;/math&gt; megabytes of storage. We cannot store them all because &lt;math&gt;D &lt; \sum_{i=1}^n s_i &lt;/math&gt;
:(a) Does a greedy algorithm that selects programs in order of non-decreasing &lt;math&gt;s_i&lt;/math&gt; maximize the number of programs held on the disk? Prove or give a counter-example.
:(b) Does a greedy algorithm that selects programs in order of non-increasing &lt;math&gt;s_i&lt;/math&gt; use as much of the capacity of the disk as possible? Prove or give a counter-example.
[[10.11|Solution]]


:10.12. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We seek an algorithm to make change of &lt;math&gt;n&lt;/math&gt; units using the minimum number of this country’s coins.
:(a) The greedy algorithm repeatedly selects the biggest coin no bigger than the amount to be changed and repeats until it is zero. Show that the greedy algorithm does not always use the minimum number of coins in a country whose denominations are {1, 6, 10}.
:(b) Give an efficient algorithm that correctly determines the minimum number of coins needed to make change of &lt;math&gt;n&lt;/math&gt; units using denominations &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt;. Analyze its running time.


:[[10.13]]. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We want to count how many distinct ways &lt;math&gt;C(n)&lt;/math&gt; there are to make change of &lt;math&gt;n&lt;/math&gt; units. For example, in a country whose denominations are {1, 6, 10}, &lt;math&gt;C(5) = 1&lt;/math&gt;, &lt;math&gt;C(6)&lt;/math&gt; to &lt;math&gt;C(9) = 2&lt;/math&gt;, &lt;math&gt;C(10) = 3&lt;/math&gt;, and &lt;math&gt;C(12) = 4&lt;/math&gt;.
:(a) How many ways are there to make change of 20 units from {1, 6, 10}?
:(b) Give an efficient algorithm to compute &lt;math&gt;C(n)&lt;/math&gt;, and analyze its complexity. (Hint: think in terms of computing &lt;math&gt;C(n, d)&lt;/math&gt;, the number of ways to make change of &lt;math&gt;n&lt;/math&gt; units with highest denomination &lt;math&gt;d&lt;/math&gt;. Be careful to avoid overcounting.)
[[10.13|Solution]]


:10.14. In the single-processor scheduling problem, we are given a set of &lt;math&gt;n&lt;/math&gt; jobs &lt;math&gt;J&lt;/math&gt;. Each job &lt;math&gt;i&lt;/math&gt; has a processing time &lt;math&gt;t_i&lt;/math&gt;, and a deadline &lt;math&gt;d_i&lt;/math&gt;. A feasible schedule is a permutation of the jobs such that when the jobs are performed in that order, every job is finished before its deadline. The greedy algorithm for single-processor scheduling selects the job with the earliest deadline first.
:Show that if a feasible schedule exists, then the schedule produced by this greedy algorithm is feasible.

===Number Problems===

:[[10.15]]. You are given a rod of length &lt;math&gt;n&lt;/math&gt; inches and a table of prices obtainable for rod-pieces of size &lt;math&gt;n&lt;/math&gt; or smaller. Give an efficient algorithm to find the maximum value obtainable by cutting up the rod and selling the pieces. For example, if &lt;math&gt;n=8&lt;/math&gt; and the values of different pieces are:
&lt;center&gt;
\begin{array}{|C|rrrrrrrr} length &amp; 1 &amp; 2 &amp; 3 &amp; 4 &amp; 5 &amp; 6 &amp; 7 &amp; 8 \\
\hline
price &amp; 1 &amp; 5 &amp; 8 &amp; 9 &amp; 10 &amp; 17 &amp;17 &amp; 20 \\
\end{array}
&lt;/center&gt;
:then the maximum obtainable value is 22, by cutting into pieces of lengths 2 and 6.
[[10.15|Solution]]


:10.16. Your boss has written an arithmetic expression of n terms to compute your annual bonus, but permits you to parenthesize it however you wish. Give an efficient algorithm to design the parenthesization to maximize the value. For the expression:
&lt;center&gt;&lt;math&gt;6 + 2 * 0 - 4&lt;/math&gt;&lt;/center&gt;
:there exist parenthesizations with values ranging from −32 to 2.


:[[10.17]]. Given a positive integer &lt;math&gt;n&lt;/math&gt;, find an efficient algorithm to compute the smallest number of perfect squares (e.g. 1, 4, 9, 16, . . .) that sum to &lt;math&gt;n&lt;/math&gt;. What is the running time of your algorithm?
[[10.17|Solution]]


:10.18. Given an array &lt;math&gt;A&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find an efficient algorithm to compute the largest sum of a continuous run. For &lt;math&gt;A = [-3, 2, 7, -3, 4, -2, 0, 1]&lt;/math&gt;, the largest such sum is 10, from the second through fifth positions.


:[[10.19]]. Two drivers have to divide up &lt;math&gt;m&lt;/math&gt; suitcases between them, where the weight of the &lt;math&gt;ith&lt;/math&gt; suitcase is &lt;math&gt;w_i&lt;/math&gt;. Give an efficient algorithm to divide up the loads so the two drivers carry equal weight, if possible.
[[10.19|Solution]]


:10.20. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = {s_1, s_2, . . . , s_n}&lt;/math&gt;, and a given target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; that adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, within &lt;math&gt;S = {1, 2, 5, 9, 10}&lt;/math&gt; there is a subset that adds up to &lt;math&gt;T = 22&lt;/math&gt; but not &lt;math&gt;T = 23&lt;/math&gt;.
:Give a dynamic programming algorithm for knapsack that runs in &lt;math&gt;O(nT)&lt;/math&gt; time.


:[[10.21]]. The integer partition takes a set of positive integers &lt;math&gt;S = {s_1, . . . , s_n}&lt;/math&gt; and seeks a subset &lt;math&gt;I \subset S&lt;/math&gt; such that
&lt;center&gt;&lt;math&gt; \sum_{i \in I} s_i = \sum_{i \notin I} s_i&lt;/math&gt;&lt;/center&gt;
:Let &lt;math&gt; \sum_{i \in S} s_i = M &lt;/math&gt;. Give an &lt;math&gt;O(nM)&lt;/math&gt; dynamic programming algorithm to solve the integer partition problem.
[[10.21|Solution]]


:10.22. Assume that there are n numbers (some possibly negative) on a circle, and we wish to find the maximum contiguous sum along an arc of the circle. Give an efficient algorithm for solving this problem.


:[[10.23]]. A certain string processing language allows the programmer to break a string into two pieces. It costs &lt;math&gt;n&lt;/math&gt; units of time to break a string of &lt;math&gt;n&lt;/math&gt; characters into two pieces, since this involves copying the old string. A programmer wants to break a string into many pieces, and the order in which the breaks are made can affect the total amount of time used. For example, suppose we wish to break a 20-character string after characters 3, 8, and 10. If the breaks are made in left-to-right order, then the first break costs 20 units of time, the second break costs 17 units of time, and the third break costs 12 units of time, for a total of 49 units. If the breaks are made in right-to-left order, the first break costs 20 units of time, the second break costs 10 units of time, and the third break costs 8 units of time, for a total of only 38 units.
:Give a dynamic programming algorithm that takes a list of character positions after which to break and determines the cheapest break cost in &lt;math&gt;O(n^3)&lt;/math&gt; time.
[[10.23|Solution]]


:10.24. Consider the following data compression technique. We have a table of &lt;math&gt;m&lt;/math&gt; text strings, each at most &lt;math&gt;k&lt;/math&gt; in length. We want to encode a data string &lt;math&gt;D&lt;/math&gt; of length &lt;math&gt;n&lt;/math&gt; using as few text strings as possible. For example, if our table contains &lt;math&gt;(a,ba,abab,b)&lt;/math&gt; and the data string is &lt;math&gt;bababbaababa&lt;/math&gt;, the best way to encode it is &lt;math&gt;(b,abab,ba,abab,a)-a&lt;/math&gt; total of five code words. Give an &lt;math&gt;O(nmk)&lt;/math&gt; algorithm to find the length of the best encoding. You may assume that every string has at least one encoding in terms of the table.


:[[10.25]]. The traditional world chess championship is a match of 24 games. The current champion retains the title in case the match is a tie. Each game ends in a win, loss, or draw (tie) where wins count as 1, losses as 0, and draws as &lt;math&gt;1/2&lt;/math&gt;. The players take turns playing white and black. White plays first and so has an advantage. The champion plays white in the first game. The champ has probabilities &lt;math&gt;w_w&lt;/math&gt;, &lt;math&gt;w_d&lt;/math&gt;, and &lt;math&gt;w_l&lt;/math&gt; of winning, drawing, and losing playing white, and has probabilities &lt;math&gt;b_w&lt;/math&gt;, &lt;math&gt;b_d&lt;/math&gt;, and &lt;math&gt;b_l&lt;/math&gt; of winning, drawing, and losing playing black.
:(a) Write a recurrence for the probability that the champion retains the title. Assume that there are &lt;math&gt;g&lt;/math&gt; games left to play in the match and that the champion needs to get &lt;math&gt;i&lt;/math&gt; points (which may be a multiple of &lt;math&gt;1/2&lt;/math&gt;).
:(b) Based on your recurrence, give a dynamic programming algorithm to calculate the champion’s probability of retaining the title.
:(c) Analyze its running time for an &lt;math&gt;n&lt;/math&gt; game match.
[[10.125|Solution]]


:10.26. Eggs break when dropped from great enough height. Specifically, there must be a floor &lt;math&gt;f&lt;/math&gt; in any sufficiently tall building such that an egg dropped from the &lt;math&gt;f&lt;/math&gt;th floor breaks, but one dropped from the &lt;math&gt;(f - 1)&lt;/math&gt;st floor will not. If the egg always breaks, then &lt;math&gt;f = 1&lt;/math&gt;. If the egg never breaks, then &lt;math&gt;f = n + 1&lt;/math&gt;. 
:You seek to find the critical floor &lt;math&gt;f&lt;/math&gt; using an &lt;math&gt;n-floor&lt;/math&gt; building. The only operation you can perform is to drop an egg off some floor and see what happens. You start out with &lt;math&gt;k&lt;/math&gt; eggs, and seek to make as few drops as possible. Broken eggs cannot be reused. Let &lt;math&gt;E(k, n)&lt;/math&gt; be the minimum number of egg drops that will always suffice.
:(a) Show that &lt;math&gt;E(1, n) = n&lt;/math&gt;.
:(b) Show that &lt;math&gt;E(k, n) = \Theta (n^{1/k})&lt;/math&gt;.
:(c) Find a recurrence for &lt;math&gt;E(k, n)&lt;/math&gt;. What is the running time of the dynamic program to find &lt;math&gt;E(k, n)&lt;/math&gt;?

===Graphing Problem===

:[[10.27]]. Consider a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. 
:Unfortunately, the city has bad neighborhoods, whose intersections we do not want to walk in. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is in a neighborhood to avoid.
:(a) Give an example of the contents of bad such that there is no path across the grid avoiding bad neighborhoods.
:(b) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find a path across the grid that avoids bad neighborhoods.
:(c) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find the shortest path across the grid that avoids bad neighborhoods. You may assume that all blocks are of equal length. For partial credit, give an &lt;math&gt;O(X^2Y^2)&lt;/math&gt; algorithm.
[[10.27|Solution]]


:10.28. Consider the same situation as the previous problem. We have a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is somewhere we want to avoid.
:If there were no bad neighborhoods to contend with, the shortest path across the grid would have length &lt;math&gt;(X - 1) + (Y - 1)&lt;/math&gt; blocks, and indeed there would be many such paths across the grid. Each path would consist of only rightward and downward moves.
:Give an algorithm that takes the array bad and returns the number of safe paths of length &lt;math&gt;X + Y - 2&lt;/math&gt;. For full credit, your algorithm must run in &lt;math&gt;O(XY)&lt;/math&gt;.


:[[10.29]]. You seek to create a stack out of &lt;math&gt;n&lt;/math&gt; boxes, where box &lt;math&gt;i&lt;/math&gt; has width &lt;math&gt;w_i&lt;/math&gt;, height &lt;math&gt;h_i&lt;/math&gt;, and depth &lt;math&gt;d_i&lt;/math&gt;. The boxes cannot be rotated, and can only be stacked on top of one another when each box in the stack is strictly larger than the box above it in width, height, and depth. Give an efficient algorithm to construct the tallest possible stack, where the height is the sum of the heights of each box in the stack.
[[10.29|Solution]]

===Design Problems===

:10.30. Consider the problem of storing &lt;math&gt;n&lt;/math&gt; books on shelves in a library. The order of the books is fixed by the cataloging system and so cannot be rearranged. Therefore, we can speak of a book &lt;math&gt;b_i&lt;/math&gt;, where &lt;math&gt;1 \leq i \leq n&lt;/math&gt;, that has a thickness &lt;math&gt;t_i&lt;/math&gt; and height &lt;math&gt;h_i&lt;/math&gt;. The length of each bookshelf at this library is &lt;math&gt;L&lt;/math&gt;.
:Suppose all the books have the same height &lt;math&gt;h&lt;/math&gt; (i.e., &lt;math&gt;h = h_i&lt;/math&gt; for all &lt;math&gt;i&lt;/math&gt;) and the shelves are all separated by a distance greater than &lt;math&gt;h&lt;/math&gt;, so any book fits on any shelf. The greedy algorithm would fill the first shelf with as many books as we can until we get the smallest &lt;math&gt;i&lt;/math&gt; such that &lt;math&gt;b_i&lt;/math&gt; does not fit, and then repeat with subsequent shelves. Show that the greedy algorithm always finds the book placement that uses the minimum number of shelves, and analyze its time complexity.


:[[10.31]]. This is a generalization of the previous problem. Now consider the case where the height of the books is not constant, but we have the freedom to adjust the height of each shelf to that of the tallest book on the shelf. Here the cost of a particular layout is the sum of the heights of the largest book on each shelf.
:#Give an example to show that the greedy algorithm of stuffing each shelf as full as possible does not always give the minimum overall height.
:#Give an algorithm for this problem, and analyze its time complexity. (Hint: use dynamic programming.)
[[10.31|Solution]]


:10.32. Consider a linear keyboard of lowercase letters and numbers, where the left-most 26 keys are the letters A–Z in order, followed by the digits 0–9 in order, followed by the 30 punctuation characters in a prescribed order, and ended on a blank. Assume you start with your left index finger on the “A” and your right index finger on the blank.
:Give a dynamic programming algorithm that finds the most efficient way to type a given text of length &lt;math&gt;n&lt;/math&gt;, in terms of minimizing total movement of the fingers involved. For the text &lt;math&gt;ABABABAB . . . ABAB&lt;/math&gt;, this would involve shifting both fingers all the way to the left side of the keyboard. Analyze the complexity of your algorithm as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;, the number of keys on the keyboard.


:[[10.33]]. You have come back from the future with an array &lt;math&gt;G&lt;/math&gt;, where &lt;math&gt;G[i]&lt;/math&gt; tells you the price of Google stock &lt;math&gt;i&lt;/math&gt; days from now, for &lt;math&gt;1 \leq i \leq n&lt;/math&gt;. You seek to use this information to maximize your profit, but are only permitted to complete at most one transaction (i.e. either buy one or sell one share of the stock) per day. Design an efficient algorithm to construct the buy–sell sequence to maximize your profit. Note that you cannot sell a share unless you currently own one.
[[10.33|Solution]]


:10.34. You are given a string of &lt;math&gt;n&lt;/math&gt; characters &lt;math&gt;S = s_1 . . . s_n&lt;/math&gt;, which you believe to be a compressed text document in which all spaces have been removed, like '''itwasthebestoftimes'''.
:(a) You seek to reconstruct the document using a dictionary, which is available in the form of a Boolean function &lt;math&gt;dict(w)&lt;/math&gt;, where &lt;math&gt;dict(w)&lt;/math&gt; is true iff string &lt;math&gt;w&lt;/math&gt; is a valid word in the language. Give an &lt;math&gt;O(n^2)&lt;/math&gt; algorithm to determine whether string &lt;math&gt;S&lt;/math&gt; can be reconstituted as a sequence of valid words, assuming calls to &lt;math&gt;dict(w &lt;/math&gt; take unit time.
:(b) Now assume you are given the dictionary as a set of &lt;math&gt;m&lt;/math&gt; words each of length at most l. Give an efficient algorithm to determine whether string &lt;math&gt;S&lt;/math&gt; can be reconstituted as a sequence of valid words, and its running time.


:[[10.35]]. Consider the following two-player game, where you seek to get the biggest score. You start with an n-digit integer &lt;math&gt;N&lt;/math&gt;. With each move, you get to take either the first digit or the last digit from what is left of &lt;math&gt;N&lt;/math&gt;, and add that to your score, with your opponent then doing the same thing to the now smaller number. You continue taking turns removing digits until none are left. Give an efficient algorithm that finds the best possible score that the first player can get for a given digit string &lt;math&gt;N&lt;/math&gt;, assuming the second player is as smart as can be.
[[10.35|Solution]]


:10.36. Given an array of &lt;math&gt;n&lt;/math&gt; real numbers, consider the problem of finding the maximum sum in any contiguous subarray of the input. For example, in the array
&lt;center&gt;&lt;math&gt;[31, -41, 59, 26, -53, 58, 97, -93, -23, 84]&lt;/math&gt;&lt;/center&gt;
:the maximum is achieved by summing the third through seventh elements, where 59 + 26 + (−53) + 58 + 97 = 187. When all numbers are positive, the entire array is the answer, while when all numbers are negative, the empty array maximizes the total at 0.
#Give a simple and clear &lt;math&gt; \Theta (n^2)&lt;/math&gt;-time algorithm to find the maximum contiguous subarray.
#Now give a &lt;math&gt;\Theta (n)&lt;/math&gt;-time dynamic programming algorithm for this problem. To get partial credit, you may instead give a correct &lt;math&gt;O(n log n)&lt;/math&gt; divide-and-conquer algorithm.


:[[10.37]]


:10.38. Let α and β be constants. Assume that it costs α to go left in a binary search tree, and β to go right. Devise an algorithm that builds a tree with optimal expected query cost, given keys &lt;math&gt;k_1, . . . , k_n&lt;/math&gt; and the probabilities that each will be searched &lt;math&gt;p_1, . . . , p_n&lt;/math&gt;.

===Interview Problems===

:[[10.39]]. Given a set of coin denominations, find the minimum number of coins to make a certain amount of change.
[[10.39|Solution]]


:10.40. You are given an array of n numbers, each of which may be positive, negative, or zero. Give an efficient algorithm to identify the index positions &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; to obtain the maximum sum of the &lt;math&gt;i&lt;/math&gt;th through &lt;math&gt;j&lt;/math&gt;th numbers.


:[[10.41]]. Observe that when you cut a character out of a magazine, the character on the reverse side of the page is also removed. Give an algorithm to determine whether you can generate a given string by pasting cutouts from a given magazine. Assume that you are given a function that will identify the character and its position on the reverse side of the page for any given character position.
[[10.41|Solution]]


Back to [[Chapter List]]</text>
      <sha1>kjaodsh3wki08822pkoqrc4vicjthbt</sha1>
    </revision>
    <revision>
      <id>228</id>
      <parentid>223</parentid>
      <timestamp>2020-09-13T21:37:51Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Number Problems */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23710">=Dynamic Programming=

===Elementary Recurrences===

:[[10.1]]. Up to &lt;math&gt;k&lt;/math&gt; steps in a single bound! A child is running up a staircase with &lt;math&gt;n&lt;/math&gt; steps and can hop between 1 and &lt;math&gt;k&lt;/math&gt; steps at a time. Design an algorithm to count how many possible ways the child can run up the stairs, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. What is the running time of your algorithm?
[[10.1|Solution]]


:10.2. Imagine you are a professional thief who plans to rob houses along a street of &lt;math&gt;n&lt;/math&gt; homes. You know the loot at house &lt;math&gt;i&lt;/math&gt; is worth &lt;math&gt;m_i&lt;/math&gt;, for &lt;math&gt;1 \le i \le n&lt;/math&gt;, but you cannot rob neighboring houses because their connected security systems will automatically contact the police if two adjacent houses are broken into. Give an efficient algorithm to determine the maximum amount of money you can steal without alerting the police.


:[[10.3]]. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible mixes (1s,2s,3s) of scoring add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are four possible solutions: (5, 0, 0), (2, 0, 1), (1, 2, 0), and (0, 1, 1).
[[10.3|Solution]]


:10.4. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible scoring sequences add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are thirteen possible sequences, including 1-2-1-1, 3-2, and 1-1-1-1-1.


:[[10.5]]. Given an &lt;math&gt;s * t&lt;/math&gt; grid filled with non-negative numbers, find a path from top left to bottom right that minimizes the sum of all numbers along its path. You can only move either down or right at any point in time.
::(a) Give a solution based on Dijkstra’s algorithm. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
::(b) Give a solution based on dynamic programming. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
[[10.5|Solution]]

===Edit Distance===

:10.6. Typists often make transposition errors exchanging neighboring characters, such as typing “setve” for “steve.” This requires two substitutions to fix under the conventional definition of edit distance.
:Incorporate a swap operation into our edit distance function, so that such neighboring transposition errors can be fixed at the cost of one operation.


:[[10.7]]. Suppose you are given three strings of characters: &lt;math&gt;X&lt;/math&gt;, &lt;math&gt;Y&lt;/math&gt;, and &lt;math&gt;Z&lt;/math&gt;, where &lt;math&gt;|X| = n&lt;/math&gt;, &lt;math&gt;|Y| = m&lt;/math&gt;, and &lt;math&gt;|Z| = n + m&lt;/math&gt;. &lt;math&gt;Z&lt;/math&gt; is said to be a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; iff &lt;math&gt;Z&lt;/math&gt; can be formed by interleaving the characters from &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; in a way that maintains the left-to-right ordering of the characters from each string. 
:(a) Show that cchocohilaptes is a shuffle of chocolate and chips, but chocochilatspe is not.
:(b) Give an efficient dynamic programming algorithm that determines whether &lt;math&gt;Z&lt;/math&gt; is a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt;. (Hint: the values of the dynamic programming matrix you construct should be Boolean, not numeric.)
[[10.7|Solution]]


:10.8. The longest common substring (not subsequence) of two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; is the longest string that appears as a run of consecutive letters in both strings. For example, the longest common substring of photograph and tomography is ograph.
:(a) Let &lt;math&gt;n = |X|&lt;/math&gt; and &lt;math&gt;m = |Y|&lt;/math&gt;. Give a &lt;math&gt;\Theta (nm)&lt;/math&gt; dynamic programming algorithm for longest common substring based on the longest common subsequence/edit distance algorithm.
:(b) Give a simpler &lt;math&gt;\Theta (nm)&lt;/math&gt; algorithm that does not rely on dynamic programming.


:[[10.9]]. The ''longest common subsequence (LCS)'' of two sequences &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the longest sequence &lt;math&gt;L&lt;/math&gt; such that &lt;math&gt;L&lt;/math&gt; is a subsequence of both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;. The ''shortest common supersequence (SCS)'' of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the smallest sequence &lt;math&gt;L&lt;/math&gt; such that both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; are a subsequence of &lt;math&gt;L&lt;/math&gt;.
:(a) Give efficient algorithms to find the LCS and SCS of two given sequences.
:(b) Let &lt;math&gt;d(T, P)&lt;/math&gt; be the minimum edit distance between &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; when no substitutions are allowed (i.e., the only changes are character insertion and deletion). Prove that &lt;math&gt;d(T, P) = |SCS(T, P)| - |LCS(T, P)|&lt;/math&gt; where &lt;math&gt;|SCS(T, P)| (|LCS(T, P)|)&lt;/math&gt; is the size of the shortest SCS (longest LCS) of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;.
[[10.9|Solution]]


:10.10. Suppose you are given &lt;math&gt;n&lt;/math&gt; poker chips stacked in two stacks, where the edges of all chips can be seen. Each chip is one of three colors. A turn consists of choosing a color and removing all chips of that color from the tops of the stacks. The goal is to minimize the number of turns until the chips are gone. 
:For example, consider the stacks &lt;math&gt;(RRGG, GBBB)&lt;/math&gt;. Playing red, green, and then blue suffices to clear the stacks in three moves. Give an &lt;math&gt;O(n^2)&lt;/math&gt; dynamic programming algorithm to find the best strategy for a given pair of chip piles.

===Greedy Algorithms===

:[[10.11]]. Let &lt;math&gt;P_1, P_2, . . . , P_n&lt;/math&gt; be &lt;math&gt;n&lt;/math&gt; programs to be stored on a disk with capacity &lt;math&gt;D&lt;/math&gt; megabytes. Program &lt;math&gt;P_i&lt;/math&gt; requires &lt;math&gt;s_i&lt;/math&gt; megabytes of storage. We cannot store them all because &lt;math&gt;D &lt; \sum_{i=1}^n s_i &lt;/math&gt;
:(a) Does a greedy algorithm that selects programs in order of non-decreasing &lt;math&gt;s_i&lt;/math&gt; maximize the number of programs held on the disk? Prove or give a counter-example.
:(b) Does a greedy algorithm that selects programs in order of non-increasing &lt;math&gt;s_i&lt;/math&gt; use as much of the capacity of the disk as possible? Prove or give a counter-example.
[[10.11|Solution]]


:10.12. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We seek an algorithm to make change of &lt;math&gt;n&lt;/math&gt; units using the minimum number of this country’s coins.
:(a) The greedy algorithm repeatedly selects the biggest coin no bigger than the amount to be changed and repeats until it is zero. Show that the greedy algorithm does not always use the minimum number of coins in a country whose denominations are {1, 6, 10}.
:(b) Give an efficient algorithm that correctly determines the minimum number of coins needed to make change of &lt;math&gt;n&lt;/math&gt; units using denominations &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt;. Analyze its running time.


:[[10.13]]. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We want to count how many distinct ways &lt;math&gt;C(n)&lt;/math&gt; there are to make change of &lt;math&gt;n&lt;/math&gt; units. For example, in a country whose denominations are {1, 6, 10}, &lt;math&gt;C(5) = 1&lt;/math&gt;, &lt;math&gt;C(6)&lt;/math&gt; to &lt;math&gt;C(9) = 2&lt;/math&gt;, &lt;math&gt;C(10) = 3&lt;/math&gt;, and &lt;math&gt;C(12) = 4&lt;/math&gt;.
:(a) How many ways are there to make change of 20 units from {1, 6, 10}?
:(b) Give an efficient algorithm to compute &lt;math&gt;C(n)&lt;/math&gt;, and analyze its complexity. (Hint: think in terms of computing &lt;math&gt;C(n, d)&lt;/math&gt;, the number of ways to make change of &lt;math&gt;n&lt;/math&gt; units with highest denomination &lt;math&gt;d&lt;/math&gt;. Be careful to avoid overcounting.)
[[10.13|Solution]]


:10.14. In the single-processor scheduling problem, we are given a set of &lt;math&gt;n&lt;/math&gt; jobs &lt;math&gt;J&lt;/math&gt;. Each job &lt;math&gt;i&lt;/math&gt; has a processing time &lt;math&gt;t_i&lt;/math&gt;, and a deadline &lt;math&gt;d_i&lt;/math&gt;. A feasible schedule is a permutation of the jobs such that when the jobs are performed in that order, every job is finished before its deadline. The greedy algorithm for single-processor scheduling selects the job with the earliest deadline first.
:Show that if a feasible schedule exists, then the schedule produced by this greedy algorithm is feasible.

===Number Problems===

:[[10.15]]. You are given a rod of length &lt;math&gt;n&lt;/math&gt; inches and a table of prices obtainable for rod-pieces of size &lt;math&gt;n&lt;/math&gt; or smaller. Give an efficient algorithm to find the maximum value obtainable by cutting up the rod and selling the pieces. For example, if &lt;math&gt;n=8&lt;/math&gt; and the values of different pieces are:
&lt;center&gt;&lt;math&gt;
\begin{array}{|C|rrrrrrrr} length &amp; 1 &amp; 2 &amp; 3 &amp; 4 &amp; 5 &amp; 6 &amp; 7 &amp; 8 \\
\hline
price &amp; 1 &amp; 5 &amp; 8 &amp; 9 &amp; 10 &amp; 17 &amp;17 &amp; 20 \\
\end{array}&lt;/math&gt;
&lt;/center&gt;
:then the maximum obtainable value is 22, by cutting into pieces of lengths 2 and 6.
[[10.15|Solution]]


:10.16. Your boss has written an arithmetic expression of n terms to compute your annual bonus, but permits you to parenthesize it however you wish. Give an efficient algorithm to design the parenthesization to maximize the value. For the expression:
&lt;center&gt;&lt;math&gt;6 + 2 * 0 - 4&lt;/math&gt;&lt;/center&gt;
:there exist parenthesizations with values ranging from −32 to 2.


:[[10.17]]. Given a positive integer &lt;math&gt;n&lt;/math&gt;, find an efficient algorithm to compute the smallest number of perfect squares (e.g. 1, 4, 9, 16, . . .) that sum to &lt;math&gt;n&lt;/math&gt;. What is the running time of your algorithm?
[[10.17|Solution]]


:10.18. Given an array &lt;math&gt;A&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find an efficient algorithm to compute the largest sum of a continuous run. For &lt;math&gt;A = [-3, 2, 7, -3, 4, -2, 0, 1]&lt;/math&gt;, the largest such sum is 10, from the second through fifth positions.


:[[10.19]]. Two drivers have to divide up &lt;math&gt;m&lt;/math&gt; suitcases between them, where the weight of the &lt;math&gt;ith&lt;/math&gt; suitcase is &lt;math&gt;w_i&lt;/math&gt;. Give an efficient algorithm to divide up the loads so the two drivers carry equal weight, if possible.
[[10.19|Solution]]


:10.20. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = {s_1, s_2, . . . , s_n}&lt;/math&gt;, and a given target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; that adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, within &lt;math&gt;S = {1, 2, 5, 9, 10}&lt;/math&gt; there is a subset that adds up to &lt;math&gt;T = 22&lt;/math&gt; but not &lt;math&gt;T = 23&lt;/math&gt;.
:Give a dynamic programming algorithm for knapsack that runs in &lt;math&gt;O(nT)&lt;/math&gt; time.


:[[10.21]]. The integer partition takes a set of positive integers &lt;math&gt;S = {s_1, . . . , s_n}&lt;/math&gt; and seeks a subset &lt;math&gt;I \subset S&lt;/math&gt; such that
&lt;center&gt;&lt;math&gt; \sum_{i \in I} s_i = \sum_{i \notin I} s_i&lt;/math&gt;&lt;/center&gt;
:Let &lt;math&gt; \sum_{i \in S} s_i = M &lt;/math&gt;. Give an &lt;math&gt;O(nM)&lt;/math&gt; dynamic programming algorithm to solve the integer partition problem.
[[10.21|Solution]]


:10.22. Assume that there are n numbers (some possibly negative) on a circle, and we wish to find the maximum contiguous sum along an arc of the circle. Give an efficient algorithm for solving this problem.


:[[10.23]]. A certain string processing language allows the programmer to break a string into two pieces. It costs &lt;math&gt;n&lt;/math&gt; units of time to break a string of &lt;math&gt;n&lt;/math&gt; characters into two pieces, since this involves copying the old string. A programmer wants to break a string into many pieces, and the order in which the breaks are made can affect the total amount of time used. For example, suppose we wish to break a 20-character string after characters 3, 8, and 10. If the breaks are made in left-to-right order, then the first break costs 20 units of time, the second break costs 17 units of time, and the third break costs 12 units of time, for a total of 49 units. If the breaks are made in right-to-left order, the first break costs 20 units of time, the second break costs 10 units of time, and the third break costs 8 units of time, for a total of only 38 units.
:Give a dynamic programming algorithm that takes a list of character positions after which to break and determines the cheapest break cost in &lt;math&gt;O(n^3)&lt;/math&gt; time.
[[10.23|Solution]]


:10.24. Consider the following data compression technique. We have a table of &lt;math&gt;m&lt;/math&gt; text strings, each at most &lt;math&gt;k&lt;/math&gt; in length. We want to encode a data string &lt;math&gt;D&lt;/math&gt; of length &lt;math&gt;n&lt;/math&gt; using as few text strings as possible. For example, if our table contains &lt;math&gt;(a,ba,abab,b)&lt;/math&gt; and the data string is &lt;math&gt;bababbaababa&lt;/math&gt;, the best way to encode it is &lt;math&gt;(b,abab,ba,abab,a)-a&lt;/math&gt; total of five code words. Give an &lt;math&gt;O(nmk)&lt;/math&gt; algorithm to find the length of the best encoding. You may assume that every string has at least one encoding in terms of the table.


:[[10.25]]. The traditional world chess championship is a match of 24 games. The current champion retains the title in case the match is a tie. Each game ends in a win, loss, or draw (tie) where wins count as 1, losses as 0, and draws as &lt;math&gt;1/2&lt;/math&gt;. The players take turns playing white and black. White plays first and so has an advantage. The champion plays white in the first game. The champ has probabilities &lt;math&gt;w_w&lt;/math&gt;, &lt;math&gt;w_d&lt;/math&gt;, and &lt;math&gt;w_l&lt;/math&gt; of winning, drawing, and losing playing white, and has probabilities &lt;math&gt;b_w&lt;/math&gt;, &lt;math&gt;b_d&lt;/math&gt;, and &lt;math&gt;b_l&lt;/math&gt; of winning, drawing, and losing playing black.
:(a) Write a recurrence for the probability that the champion retains the title. Assume that there are &lt;math&gt;g&lt;/math&gt; games left to play in the match and that the champion needs to get &lt;math&gt;i&lt;/math&gt; points (which may be a multiple of &lt;math&gt;1/2&lt;/math&gt;).
:(b) Based on your recurrence, give a dynamic programming algorithm to calculate the champion’s probability of retaining the title.
:(c) Analyze its running time for an &lt;math&gt;n&lt;/math&gt; game match.
[[10.125|Solution]]


:10.26. Eggs break when dropped from great enough height. Specifically, there must be a floor &lt;math&gt;f&lt;/math&gt; in any sufficiently tall building such that an egg dropped from the &lt;math&gt;f&lt;/math&gt;th floor breaks, but one dropped from the &lt;math&gt;(f - 1)&lt;/math&gt;st floor will not. If the egg always breaks, then &lt;math&gt;f = 1&lt;/math&gt;. If the egg never breaks, then &lt;math&gt;f = n + 1&lt;/math&gt;. 
:You seek to find the critical floor &lt;math&gt;f&lt;/math&gt; using an &lt;math&gt;n-floor&lt;/math&gt; building. The only operation you can perform is to drop an egg off some floor and see what happens. You start out with &lt;math&gt;k&lt;/math&gt; eggs, and seek to make as few drops as possible. Broken eggs cannot be reused. Let &lt;math&gt;E(k, n)&lt;/math&gt; be the minimum number of egg drops that will always suffice.
:(a) Show that &lt;math&gt;E(1, n) = n&lt;/math&gt;.
:(b) Show that &lt;math&gt;E(k, n) = \Theta (n^{1/k})&lt;/math&gt;.
:(c) Find a recurrence for &lt;math&gt;E(k, n)&lt;/math&gt;. What is the running time of the dynamic program to find &lt;math&gt;E(k, n)&lt;/math&gt;?

===Graphing Problem===

:[[10.27]]. Consider a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. 
:Unfortunately, the city has bad neighborhoods, whose intersections we do not want to walk in. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is in a neighborhood to avoid.
:(a) Give an example of the contents of bad such that there is no path across the grid avoiding bad neighborhoods.
:(b) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find a path across the grid that avoids bad neighborhoods.
:(c) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find the shortest path across the grid that avoids bad neighborhoods. You may assume that all blocks are of equal length. For partial credit, give an &lt;math&gt;O(X^2Y^2)&lt;/math&gt; algorithm.
[[10.27|Solution]]


:10.28. Consider the same situation as the previous problem. We have a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is somewhere we want to avoid.
:If there were no bad neighborhoods to contend with, the shortest path across the grid would have length &lt;math&gt;(X - 1) + (Y - 1)&lt;/math&gt; blocks, and indeed there would be many such paths across the grid. Each path would consist of only rightward and downward moves.
:Give an algorithm that takes the array bad and returns the number of safe paths of length &lt;math&gt;X + Y - 2&lt;/math&gt;. For full credit, your algorithm must run in &lt;math&gt;O(XY)&lt;/math&gt;.


:[[10.29]]. You seek to create a stack out of &lt;math&gt;n&lt;/math&gt; boxes, where box &lt;math&gt;i&lt;/math&gt; has width &lt;math&gt;w_i&lt;/math&gt;, height &lt;math&gt;h_i&lt;/math&gt;, and depth &lt;math&gt;d_i&lt;/math&gt;. The boxes cannot be rotated, and can only be stacked on top of one another when each box in the stack is strictly larger than the box above it in width, height, and depth. Give an efficient algorithm to construct the tallest possible stack, where the height is the sum of the heights of each box in the stack.
[[10.29|Solution]]

===Design Problems===

:10.30. Consider the problem of storing &lt;math&gt;n&lt;/math&gt; books on shelves in a library. The order of the books is fixed by the cataloging system and so cannot be rearranged. Therefore, we can speak of a book &lt;math&gt;b_i&lt;/math&gt;, where &lt;math&gt;1 \leq i \leq n&lt;/math&gt;, that has a thickness &lt;math&gt;t_i&lt;/math&gt; and height &lt;math&gt;h_i&lt;/math&gt;. The length of each bookshelf at this library is &lt;math&gt;L&lt;/math&gt;.
:Suppose all the books have the same height &lt;math&gt;h&lt;/math&gt; (i.e., &lt;math&gt;h = h_i&lt;/math&gt; for all &lt;math&gt;i&lt;/math&gt;) and the shelves are all separated by a distance greater than &lt;math&gt;h&lt;/math&gt;, so any book fits on any shelf. The greedy algorithm would fill the first shelf with as many books as we can until we get the smallest &lt;math&gt;i&lt;/math&gt; such that &lt;math&gt;b_i&lt;/math&gt; does not fit, and then repeat with subsequent shelves. Show that the greedy algorithm always finds the book placement that uses the minimum number of shelves, and analyze its time complexity.


:[[10.31]]. This is a generalization of the previous problem. Now consider the case where the height of the books is not constant, but we have the freedom to adjust the height of each shelf to that of the tallest book on the shelf. Here the cost of a particular layout is the sum of the heights of the largest book on each shelf.
:#Give an example to show that the greedy algorithm of stuffing each shelf as full as possible does not always give the minimum overall height.
:#Give an algorithm for this problem, and analyze its time complexity. (Hint: use dynamic programming.)
[[10.31|Solution]]


:10.32. Consider a linear keyboard of lowercase letters and numbers, where the left-most 26 keys are the letters A–Z in order, followed by the digits 0–9 in order, followed by the 30 punctuation characters in a prescribed order, and ended on a blank. Assume you start with your left index finger on the “A” and your right index finger on the blank.
:Give a dynamic programming algorithm that finds the most efficient way to type a given text of length &lt;math&gt;n&lt;/math&gt;, in terms of minimizing total movement of the fingers involved. For the text &lt;math&gt;ABABABAB . . . ABAB&lt;/math&gt;, this would involve shifting both fingers all the way to the left side of the keyboard. Analyze the complexity of your algorithm as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;, the number of keys on the keyboard.


:[[10.33]]. You have come back from the future with an array &lt;math&gt;G&lt;/math&gt;, where &lt;math&gt;G[i]&lt;/math&gt; tells you the price of Google stock &lt;math&gt;i&lt;/math&gt; days from now, for &lt;math&gt;1 \leq i \leq n&lt;/math&gt;. You seek to use this information to maximize your profit, but are only permitted to complete at most one transaction (i.e. either buy one or sell one share of the stock) per day. Design an efficient algorithm to construct the buy–sell sequence to maximize your profit. Note that you cannot sell a share unless you currently own one.
[[10.33|Solution]]


:10.34. You are given a string of &lt;math&gt;n&lt;/math&gt; characters &lt;math&gt;S = s_1 . . . s_n&lt;/math&gt;, which you believe to be a compressed text document in which all spaces have been removed, like '''itwasthebestoftimes'''.
:(a) You seek to reconstruct the document using a dictionary, which is available in the form of a Boolean function &lt;math&gt;dict(w)&lt;/math&gt;, where &lt;math&gt;dict(w)&lt;/math&gt; is true iff string &lt;math&gt;w&lt;/math&gt; is a valid word in the language. Give an &lt;math&gt;O(n^2)&lt;/math&gt; algorithm to determine whether string &lt;math&gt;S&lt;/math&gt; can be reconstituted as a sequence of valid words, assuming calls to &lt;math&gt;dict(w &lt;/math&gt; take unit time.
:(b) Now assume you are given the dictionary as a set of &lt;math&gt;m&lt;/math&gt; words each of length at most l. Give an efficient algorithm to determine whether string &lt;math&gt;S&lt;/math&gt; can be reconstituted as a sequence of valid words, and its running time.


:[[10.35]]. Consider the following two-player game, where you seek to get the biggest score. You start with an n-digit integer &lt;math&gt;N&lt;/math&gt;. With each move, you get to take either the first digit or the last digit from what is left of &lt;math&gt;N&lt;/math&gt;, and add that to your score, with your opponent then doing the same thing to the now smaller number. You continue taking turns removing digits until none are left. Give an efficient algorithm that finds the best possible score that the first player can get for a given digit string &lt;math&gt;N&lt;/math&gt;, assuming the second player is as smart as can be.
[[10.35|Solution]]


:10.36. Given an array of &lt;math&gt;n&lt;/math&gt; real numbers, consider the problem of finding the maximum sum in any contiguous subarray of the input. For example, in the array
&lt;center&gt;&lt;math&gt;[31, -41, 59, 26, -53, 58, 97, -93, -23, 84]&lt;/math&gt;&lt;/center&gt;
:the maximum is achieved by summing the third through seventh elements, where 59 + 26 + (−53) + 58 + 97 = 187. When all numbers are positive, the entire array is the answer, while when all numbers are negative, the empty array maximizes the total at 0.
#Give a simple and clear &lt;math&gt; \Theta (n^2)&lt;/math&gt;-time algorithm to find the maximum contiguous subarray.
#Now give a &lt;math&gt;\Theta (n)&lt;/math&gt;-time dynamic programming algorithm for this problem. To get partial credit, you may instead give a correct &lt;math&gt;O(n log n)&lt;/math&gt; divide-and-conquer algorithm.


:[[10.37]]


:10.38. Let α and β be constants. Assume that it costs α to go left in a binary search tree, and β to go right. Devise an algorithm that builds a tree with optimal expected query cost, given keys &lt;math&gt;k_1, . . . , k_n&lt;/math&gt; and the probabilities that each will be searched &lt;math&gt;p_1, . . . , p_n&lt;/math&gt;.

===Interview Problems===

:[[10.39]]. Given a set of coin denominations, find the minimum number of coins to make a certain amount of change.
[[10.39|Solution]]


:10.40. You are given an array of n numbers, each of which may be positive, negative, or zero. Give an efficient algorithm to identify the index positions &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; to obtain the maximum sum of the &lt;math&gt;i&lt;/math&gt;th through &lt;math&gt;j&lt;/math&gt;th numbers.


:[[10.41]]. Observe that when you cut a character out of a magazine, the character on the reverse side of the page is also removed. Give an algorithm to determine whether you can generate a given string by pasting cutouts from a given magazine. Assume that you are given a function that will identify the character and its position on the reverse side of the page for any given character position.
[[10.41|Solution]]


Back to [[Chapter List]]</text>
      <sha1>c02s01vlkjwm0i6zz5wwx43qnkc9667</sha1>
    </revision>
    <revision>
      <id>378</id>
      <parentid>228</parentid>
      <timestamp>2020-09-21T01:19:01Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Number Problems */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23712">=Dynamic Programming=

===Elementary Recurrences===

:[[10.1]]. Up to &lt;math&gt;k&lt;/math&gt; steps in a single bound! A child is running up a staircase with &lt;math&gt;n&lt;/math&gt; steps and can hop between 1 and &lt;math&gt;k&lt;/math&gt; steps at a time. Design an algorithm to count how many possible ways the child can run up the stairs, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. What is the running time of your algorithm?
[[10.1|Solution]]


:10.2. Imagine you are a professional thief who plans to rob houses along a street of &lt;math&gt;n&lt;/math&gt; homes. You know the loot at house &lt;math&gt;i&lt;/math&gt; is worth &lt;math&gt;m_i&lt;/math&gt;, for &lt;math&gt;1 \le i \le n&lt;/math&gt;, but you cannot rob neighboring houses because their connected security systems will automatically contact the police if two adjacent houses are broken into. Give an efficient algorithm to determine the maximum amount of money you can steal without alerting the police.


:[[10.3]]. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible mixes (1s,2s,3s) of scoring add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are four possible solutions: (5, 0, 0), (2, 0, 1), (1, 2, 0), and (0, 1, 1).
[[10.3|Solution]]


:10.4. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible scoring sequences add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are thirteen possible sequences, including 1-2-1-1, 3-2, and 1-1-1-1-1.


:[[10.5]]. Given an &lt;math&gt;s * t&lt;/math&gt; grid filled with non-negative numbers, find a path from top left to bottom right that minimizes the sum of all numbers along its path. You can only move either down or right at any point in time.
::(a) Give a solution based on Dijkstra’s algorithm. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
::(b) Give a solution based on dynamic programming. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
[[10.5|Solution]]

===Edit Distance===

:10.6. Typists often make transposition errors exchanging neighboring characters, such as typing “setve” for “steve.” This requires two substitutions to fix under the conventional definition of edit distance.
:Incorporate a swap operation into our edit distance function, so that such neighboring transposition errors can be fixed at the cost of one operation.


:[[10.7]]. Suppose you are given three strings of characters: &lt;math&gt;X&lt;/math&gt;, &lt;math&gt;Y&lt;/math&gt;, and &lt;math&gt;Z&lt;/math&gt;, where &lt;math&gt;|X| = n&lt;/math&gt;, &lt;math&gt;|Y| = m&lt;/math&gt;, and &lt;math&gt;|Z| = n + m&lt;/math&gt;. &lt;math&gt;Z&lt;/math&gt; is said to be a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; iff &lt;math&gt;Z&lt;/math&gt; can be formed by interleaving the characters from &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; in a way that maintains the left-to-right ordering of the characters from each string. 
:(a) Show that cchocohilaptes is a shuffle of chocolate and chips, but chocochilatspe is not.
:(b) Give an efficient dynamic programming algorithm that determines whether &lt;math&gt;Z&lt;/math&gt; is a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt;. (Hint: the values of the dynamic programming matrix you construct should be Boolean, not numeric.)
[[10.7|Solution]]


:10.8. The longest common substring (not subsequence) of two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; is the longest string that appears as a run of consecutive letters in both strings. For example, the longest common substring of photograph and tomography is ograph.
:(a) Let &lt;math&gt;n = |X|&lt;/math&gt; and &lt;math&gt;m = |Y|&lt;/math&gt;. Give a &lt;math&gt;\Theta (nm)&lt;/math&gt; dynamic programming algorithm for longest common substring based on the longest common subsequence/edit distance algorithm.
:(b) Give a simpler &lt;math&gt;\Theta (nm)&lt;/math&gt; algorithm that does not rely on dynamic programming.


:[[10.9]]. The ''longest common subsequence (LCS)'' of two sequences &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the longest sequence &lt;math&gt;L&lt;/math&gt; such that &lt;math&gt;L&lt;/math&gt; is a subsequence of both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;. The ''shortest common supersequence (SCS)'' of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the smallest sequence &lt;math&gt;L&lt;/math&gt; such that both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; are a subsequence of &lt;math&gt;L&lt;/math&gt;.
:(a) Give efficient algorithms to find the LCS and SCS of two given sequences.
:(b) Let &lt;math&gt;d(T, P)&lt;/math&gt; be the minimum edit distance between &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; when no substitutions are allowed (i.e., the only changes are character insertion and deletion). Prove that &lt;math&gt;d(T, P) = |SCS(T, P)| - |LCS(T, P)|&lt;/math&gt; where &lt;math&gt;|SCS(T, P)| (|LCS(T, P)|)&lt;/math&gt; is the size of the shortest SCS (longest LCS) of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;.
[[10.9|Solution]]


:10.10. Suppose you are given &lt;math&gt;n&lt;/math&gt; poker chips stacked in two stacks, where the edges of all chips can be seen. Each chip is one of three colors. A turn consists of choosing a color and removing all chips of that color from the tops of the stacks. The goal is to minimize the number of turns until the chips are gone. 
:For example, consider the stacks &lt;math&gt;(RRGG, GBBB)&lt;/math&gt;. Playing red, green, and then blue suffices to clear the stacks in three moves. Give an &lt;math&gt;O(n^2)&lt;/math&gt; dynamic programming algorithm to find the best strategy for a given pair of chip piles.

===Greedy Algorithms===

:[[10.11]]. Let &lt;math&gt;P_1, P_2, . . . , P_n&lt;/math&gt; be &lt;math&gt;n&lt;/math&gt; programs to be stored on a disk with capacity &lt;math&gt;D&lt;/math&gt; megabytes. Program &lt;math&gt;P_i&lt;/math&gt; requires &lt;math&gt;s_i&lt;/math&gt; megabytes of storage. We cannot store them all because &lt;math&gt;D &lt; \sum_{i=1}^n s_i &lt;/math&gt;
:(a) Does a greedy algorithm that selects programs in order of non-decreasing &lt;math&gt;s_i&lt;/math&gt; maximize the number of programs held on the disk? Prove or give a counter-example.
:(b) Does a greedy algorithm that selects programs in order of non-increasing &lt;math&gt;s_i&lt;/math&gt; use as much of the capacity of the disk as possible? Prove or give a counter-example.
[[10.11|Solution]]


:10.12. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We seek an algorithm to make change of &lt;math&gt;n&lt;/math&gt; units using the minimum number of this country’s coins.
:(a) The greedy algorithm repeatedly selects the biggest coin no bigger than the amount to be changed and repeats until it is zero. Show that the greedy algorithm does not always use the minimum number of coins in a country whose denominations are {1, 6, 10}.
:(b) Give an efficient algorithm that correctly determines the minimum number of coins needed to make change of &lt;math&gt;n&lt;/math&gt; units using denominations &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt;. Analyze its running time.


:[[10.13]]. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We want to count how many distinct ways &lt;math&gt;C(n)&lt;/math&gt; there are to make change of &lt;math&gt;n&lt;/math&gt; units. For example, in a country whose denominations are {1, 6, 10}, &lt;math&gt;C(5) = 1&lt;/math&gt;, &lt;math&gt;C(6)&lt;/math&gt; to &lt;math&gt;C(9) = 2&lt;/math&gt;, &lt;math&gt;C(10) = 3&lt;/math&gt;, and &lt;math&gt;C(12) = 4&lt;/math&gt;.
:(a) How many ways are there to make change of 20 units from {1, 6, 10}?
:(b) Give an efficient algorithm to compute &lt;math&gt;C(n)&lt;/math&gt;, and analyze its complexity. (Hint: think in terms of computing &lt;math&gt;C(n, d)&lt;/math&gt;, the number of ways to make change of &lt;math&gt;n&lt;/math&gt; units with highest denomination &lt;math&gt;d&lt;/math&gt;. Be careful to avoid overcounting.)
[[10.13|Solution]]


:10.14. In the single-processor scheduling problem, we are given a set of &lt;math&gt;n&lt;/math&gt; jobs &lt;math&gt;J&lt;/math&gt;. Each job &lt;math&gt;i&lt;/math&gt; has a processing time &lt;math&gt;t_i&lt;/math&gt;, and a deadline &lt;math&gt;d_i&lt;/math&gt;. A feasible schedule is a permutation of the jobs such that when the jobs are performed in that order, every job is finished before its deadline. The greedy algorithm for single-processor scheduling selects the job with the earliest deadline first.
:Show that if a feasible schedule exists, then the schedule produced by this greedy algorithm is feasible.

===Number Problems===

:[[10.15]]. You are given a rod of length &lt;math&gt;n&lt;/math&gt; inches and a table of prices obtainable for rod-pieces of size &lt;math&gt;n&lt;/math&gt; or smaller. Give an efficient algorithm to find the maximum value obtainable by cutting up the rod and selling the pieces. For example, if &lt;math&gt;n=8&lt;/math&gt; and the values of different pieces are:
&lt;center&gt;&lt;math&gt;
\begin{array}{|C|111111111} length &amp; 1 &amp; 2 &amp; 3 &amp; 4 &amp; 5 &amp; 6 &amp; 7 &amp; 8 \\
\hline
price &amp; 1 &amp; 5 &amp; 8 &amp; 9 &amp; 10 &amp; 17 &amp; 17 &amp; 20 \\
\end{array}&lt;/math&gt;
&lt;/center&gt;
:then the maximum obtainable value is 22, by cutting into pieces of lengths 2 and 6.
[[10.15|Solution]]


:10.16. Your boss has written an arithmetic expression of n terms to compute your annual bonus, but permits you to parenthesize it however you wish. Give an efficient algorithm to design the parenthesization to maximize the value. For the expression:
&lt;center&gt;&lt;math&gt;6 + 2 * 0 - 4&lt;/math&gt;&lt;/center&gt;
:there exist parenthesizations with values ranging from −32 to 2.


:[[10.17]]. Given a positive integer &lt;math&gt;n&lt;/math&gt;, find an efficient algorithm to compute the smallest number of perfect squares (e.g. 1, 4, 9, 16, . . .) that sum to &lt;math&gt;n&lt;/math&gt;. What is the running time of your algorithm?
[[10.17|Solution]]


:10.18. Given an array &lt;math&gt;A&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find an efficient algorithm to compute the largest sum of a continuous run. For &lt;math&gt;A = [-3, 2, 7, -3, 4, -2, 0, 1]&lt;/math&gt;, the largest such sum is 10, from the second through fifth positions.


:[[10.19]]. Two drivers have to divide up &lt;math&gt;m&lt;/math&gt; suitcases between them, where the weight of the &lt;math&gt;ith&lt;/math&gt; suitcase is &lt;math&gt;w_i&lt;/math&gt;. Give an efficient algorithm to divide up the loads so the two drivers carry equal weight, if possible.
[[10.19|Solution]]


:10.20. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = {s_1, s_2, . . . , s_n}&lt;/math&gt;, and a given target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; that adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, within &lt;math&gt;S = {1, 2, 5, 9, 10}&lt;/math&gt; there is a subset that adds up to &lt;math&gt;T = 22&lt;/math&gt; but not &lt;math&gt;T = 23&lt;/math&gt;.
:Give a dynamic programming algorithm for knapsack that runs in &lt;math&gt;O(nT)&lt;/math&gt; time.


:[[10.21]]. The integer partition takes a set of positive integers &lt;math&gt;S = {s_1, . . . , s_n}&lt;/math&gt; and seeks a subset &lt;math&gt;I \subset S&lt;/math&gt; such that
&lt;center&gt;&lt;math&gt; \sum_{i \in I} s_i = \sum_{i \notin I} s_i&lt;/math&gt;&lt;/center&gt;
:Let &lt;math&gt; \sum_{i \in S} s_i = M &lt;/math&gt;. Give an &lt;math&gt;O(nM)&lt;/math&gt; dynamic programming algorithm to solve the integer partition problem.
[[10.21|Solution]]


:10.22. Assume that there are n numbers (some possibly negative) on a circle, and we wish to find the maximum contiguous sum along an arc of the circle. Give an efficient algorithm for solving this problem.


:[[10.23]]. A certain string processing language allows the programmer to break a string into two pieces. It costs &lt;math&gt;n&lt;/math&gt; units of time to break a string of &lt;math&gt;n&lt;/math&gt; characters into two pieces, since this involves copying the old string. A programmer wants to break a string into many pieces, and the order in which the breaks are made can affect the total amount of time used. For example, suppose we wish to break a 20-character string after characters 3, 8, and 10. If the breaks are made in left-to-right order, then the first break costs 20 units of time, the second break costs 17 units of time, and the third break costs 12 units of time, for a total of 49 units. If the breaks are made in right-to-left order, the first break costs 20 units of time, the second break costs 10 units of time, and the third break costs 8 units of time, for a total of only 38 units.
:Give a dynamic programming algorithm that takes a list of character positions after which to break and determines the cheapest break cost in &lt;math&gt;O(n^3)&lt;/math&gt; time.
[[10.23|Solution]]


:10.24. Consider the following data compression technique. We have a table of &lt;math&gt;m&lt;/math&gt; text strings, each at most &lt;math&gt;k&lt;/math&gt; in length. We want to encode a data string &lt;math&gt;D&lt;/math&gt; of length &lt;math&gt;n&lt;/math&gt; using as few text strings as possible. For example, if our table contains &lt;math&gt;(a,ba,abab,b)&lt;/math&gt; and the data string is &lt;math&gt;bababbaababa&lt;/math&gt;, the best way to encode it is &lt;math&gt;(b,abab,ba,abab,a)-a&lt;/math&gt; total of five code words. Give an &lt;math&gt;O(nmk)&lt;/math&gt; algorithm to find the length of the best encoding. You may assume that every string has at least one encoding in terms of the table.


:[[10.25]]. The traditional world chess championship is a match of 24 games. The current champion retains the title in case the match is a tie. Each game ends in a win, loss, or draw (tie) where wins count as 1, losses as 0, and draws as &lt;math&gt;1/2&lt;/math&gt;. The players take turns playing white and black. White plays first and so has an advantage. The champion plays white in the first game. The champ has probabilities &lt;math&gt;w_w&lt;/math&gt;, &lt;math&gt;w_d&lt;/math&gt;, and &lt;math&gt;w_l&lt;/math&gt; of winning, drawing, and losing playing white, and has probabilities &lt;math&gt;b_w&lt;/math&gt;, &lt;math&gt;b_d&lt;/math&gt;, and &lt;math&gt;b_l&lt;/math&gt; of winning, drawing, and losing playing black.
:(a) Write a recurrence for the probability that the champion retains the title. Assume that there are &lt;math&gt;g&lt;/math&gt; games left to play in the match and that the champion needs to get &lt;math&gt;i&lt;/math&gt; points (which may be a multiple of &lt;math&gt;1/2&lt;/math&gt;).
:(b) Based on your recurrence, give a dynamic programming algorithm to calculate the champion’s probability of retaining the title.
:(c) Analyze its running time for an &lt;math&gt;n&lt;/math&gt; game match.
[[10.125|Solution]]


:10.26. Eggs break when dropped from great enough height. Specifically, there must be a floor &lt;math&gt;f&lt;/math&gt; in any sufficiently tall building such that an egg dropped from the &lt;math&gt;f&lt;/math&gt;th floor breaks, but one dropped from the &lt;math&gt;(f - 1)&lt;/math&gt;st floor will not. If the egg always breaks, then &lt;math&gt;f = 1&lt;/math&gt;. If the egg never breaks, then &lt;math&gt;f = n + 1&lt;/math&gt;. 
:You seek to find the critical floor &lt;math&gt;f&lt;/math&gt; using an &lt;math&gt;n-floor&lt;/math&gt; building. The only operation you can perform is to drop an egg off some floor and see what happens. You start out with &lt;math&gt;k&lt;/math&gt; eggs, and seek to make as few drops as possible. Broken eggs cannot be reused. Let &lt;math&gt;E(k, n)&lt;/math&gt; be the minimum number of egg drops that will always suffice.
:(a) Show that &lt;math&gt;E(1, n) = n&lt;/math&gt;.
:(b) Show that &lt;math&gt;E(k, n) = \Theta (n^{1/k})&lt;/math&gt;.
:(c) Find a recurrence for &lt;math&gt;E(k, n)&lt;/math&gt;. What is the running time of the dynamic program to find &lt;math&gt;E(k, n)&lt;/math&gt;?

===Graphing Problem===

:[[10.27]]. Consider a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. 
:Unfortunately, the city has bad neighborhoods, whose intersections we do not want to walk in. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is in a neighborhood to avoid.
:(a) Give an example of the contents of bad such that there is no path across the grid avoiding bad neighborhoods.
:(b) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find a path across the grid that avoids bad neighborhoods.
:(c) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find the shortest path across the grid that avoids bad neighborhoods. You may assume that all blocks are of equal length. For partial credit, give an &lt;math&gt;O(X^2Y^2)&lt;/math&gt; algorithm.
[[10.27|Solution]]


:10.28. Consider the same situation as the previous problem. We have a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is somewhere we want to avoid.
:If there were no bad neighborhoods to contend with, the shortest path across the grid would have length &lt;math&gt;(X - 1) + (Y - 1)&lt;/math&gt; blocks, and indeed there would be many such paths across the grid. Each path would consist of only rightward and downward moves.
:Give an algorithm that takes the array bad and returns the number of safe paths of length &lt;math&gt;X + Y - 2&lt;/math&gt;. For full credit, your algorithm must run in &lt;math&gt;O(XY)&lt;/math&gt;.


:[[10.29]]. You seek to create a stack out of &lt;math&gt;n&lt;/math&gt; boxes, where box &lt;math&gt;i&lt;/math&gt; has width &lt;math&gt;w_i&lt;/math&gt;, height &lt;math&gt;h_i&lt;/math&gt;, and depth &lt;math&gt;d_i&lt;/math&gt;. The boxes cannot be rotated, and can only be stacked on top of one another when each box in the stack is strictly larger than the box above it in width, height, and depth. Give an efficient algorithm to construct the tallest possible stack, where the height is the sum of the heights of each box in the stack.
[[10.29|Solution]]

===Design Problems===

:10.30. Consider the problem of storing &lt;math&gt;n&lt;/math&gt; books on shelves in a library. The order of the books is fixed by the cataloging system and so cannot be rearranged. Therefore, we can speak of a book &lt;math&gt;b_i&lt;/math&gt;, where &lt;math&gt;1 \leq i \leq n&lt;/math&gt;, that has a thickness &lt;math&gt;t_i&lt;/math&gt; and height &lt;math&gt;h_i&lt;/math&gt;. The length of each bookshelf at this library is &lt;math&gt;L&lt;/math&gt;.
:Suppose all the books have the same height &lt;math&gt;h&lt;/math&gt; (i.e., &lt;math&gt;h = h_i&lt;/math&gt; for all &lt;math&gt;i&lt;/math&gt;) and the shelves are all separated by a distance greater than &lt;math&gt;h&lt;/math&gt;, so any book fits on any shelf. The greedy algorithm would fill the first shelf with as many books as we can until we get the smallest &lt;math&gt;i&lt;/math&gt; such that &lt;math&gt;b_i&lt;/math&gt; does not fit, and then repeat with subsequent shelves. Show that the greedy algorithm always finds the book placement that uses the minimum number of shelves, and analyze its time complexity.


:[[10.31]]. This is a generalization of the previous problem. Now consider the case where the height of the books is not constant, but we have the freedom to adjust the height of each shelf to that of the tallest book on the shelf. Here the cost of a particular layout is the sum of the heights of the largest book on each shelf.
:#Give an example to show that the greedy algorithm of stuffing each shelf as full as possible does not always give the minimum overall height.
:#Give an algorithm for this problem, and analyze its time complexity. (Hint: use dynamic programming.)
[[10.31|Solution]]


:10.32. Consider a linear keyboard of lowercase letters and numbers, where the left-most 26 keys are the letters A–Z in order, followed by the digits 0–9 in order, followed by the 30 punctuation characters in a prescribed order, and ended on a blank. Assume you start with your left index finger on the “A” and your right index finger on the blank.
:Give a dynamic programming algorithm that finds the most efficient way to type a given text of length &lt;math&gt;n&lt;/math&gt;, in terms of minimizing total movement of the fingers involved. For the text &lt;math&gt;ABABABAB . . . ABAB&lt;/math&gt;, this would involve shifting both fingers all the way to the left side of the keyboard. Analyze the complexity of your algorithm as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;, the number of keys on the keyboard.


:[[10.33]]. You have come back from the future with an array &lt;math&gt;G&lt;/math&gt;, where &lt;math&gt;G[i]&lt;/math&gt; tells you the price of Google stock &lt;math&gt;i&lt;/math&gt; days from now, for &lt;math&gt;1 \leq i \leq n&lt;/math&gt;. You seek to use this information to maximize your profit, but are only permitted to complete at most one transaction (i.e. either buy one or sell one share of the stock) per day. Design an efficient algorithm to construct the buy–sell sequence to maximize your profit. Note that you cannot sell a share unless you currently own one.
[[10.33|Solution]]


:10.34. You are given a string of &lt;math&gt;n&lt;/math&gt; characters &lt;math&gt;S = s_1 . . . s_n&lt;/math&gt;, which you believe to be a compressed text document in which all spaces have been removed, like '''itwasthebestoftimes'''.
:(a) You seek to reconstruct the document using a dictionary, which is available in the form of a Boolean function &lt;math&gt;dict(w)&lt;/math&gt;, where &lt;math&gt;dict(w)&lt;/math&gt; is true iff string &lt;math&gt;w&lt;/math&gt; is a valid word in the language. Give an &lt;math&gt;O(n^2)&lt;/math&gt; algorithm to determine whether string &lt;math&gt;S&lt;/math&gt; can be reconstituted as a sequence of valid words, assuming calls to &lt;math&gt;dict(w &lt;/math&gt; take unit time.
:(b) Now assume you are given the dictionary as a set of &lt;math&gt;m&lt;/math&gt; words each of length at most l. Give an efficient algorithm to determine whether string &lt;math&gt;S&lt;/math&gt; can be reconstituted as a sequence of valid words, and its running time.


:[[10.35]]. Consider the following two-player game, where you seek to get the biggest score. You start with an n-digit integer &lt;math&gt;N&lt;/math&gt;. With each move, you get to take either the first digit or the last digit from what is left of &lt;math&gt;N&lt;/math&gt;, and add that to your score, with your opponent then doing the same thing to the now smaller number. You continue taking turns removing digits until none are left. Give an efficient algorithm that finds the best possible score that the first player can get for a given digit string &lt;math&gt;N&lt;/math&gt;, assuming the second player is as smart as can be.
[[10.35|Solution]]


:10.36. Given an array of &lt;math&gt;n&lt;/math&gt; real numbers, consider the problem of finding the maximum sum in any contiguous subarray of the input. For example, in the array
&lt;center&gt;&lt;math&gt;[31, -41, 59, 26, -53, 58, 97, -93, -23, 84]&lt;/math&gt;&lt;/center&gt;
:the maximum is achieved by summing the third through seventh elements, where 59 + 26 + (−53) + 58 + 97 = 187. When all numbers are positive, the entire array is the answer, while when all numbers are negative, the empty array maximizes the total at 0.
#Give a simple and clear &lt;math&gt; \Theta (n^2)&lt;/math&gt;-time algorithm to find the maximum contiguous subarray.
#Now give a &lt;math&gt;\Theta (n)&lt;/math&gt;-time dynamic programming algorithm for this problem. To get partial credit, you may instead give a correct &lt;math&gt;O(n log n)&lt;/math&gt; divide-and-conquer algorithm.


:[[10.37]]


:10.38. Let α and β be constants. Assume that it costs α to go left in a binary search tree, and β to go right. Devise an algorithm that builds a tree with optimal expected query cost, given keys &lt;math&gt;k_1, . . . , k_n&lt;/math&gt; and the probabilities that each will be searched &lt;math&gt;p_1, . . . , p_n&lt;/math&gt;.

===Interview Problems===

:[[10.39]]. Given a set of coin denominations, find the minimum number of coins to make a certain amount of change.
[[10.39|Solution]]


:10.40. You are given an array of n numbers, each of which may be positive, negative, or zero. Give an efficient algorithm to identify the index positions &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; to obtain the maximum sum of the &lt;math&gt;i&lt;/math&gt;th through &lt;math&gt;j&lt;/math&gt;th numbers.


:[[10.41]]. Observe that when you cut a character out of a magazine, the character on the reverse side of the page is also removed. Give an algorithm to determine whether you can generate a given string by pasting cutouts from a given magazine. Assume that you are given a function that will identify the character and its position on the reverse side of the page for any given character position.
[[10.41|Solution]]


Back to [[Chapter List]]</text>
      <sha1>sldqzlxecmkvygl043idxn337kx7tpk</sha1>
    </revision>
    <revision>
      <id>379</id>
      <parentid>378</parentid>
      <timestamp>2020-09-21T01:29:02Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Number Problems */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23703">=Dynamic Programming=

===Elementary Recurrences===

:[[10.1]]. Up to &lt;math&gt;k&lt;/math&gt; steps in a single bound! A child is running up a staircase with &lt;math&gt;n&lt;/math&gt; steps and can hop between 1 and &lt;math&gt;k&lt;/math&gt; steps at a time. Design an algorithm to count how many possible ways the child can run up the stairs, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. What is the running time of your algorithm?
[[10.1|Solution]]


:10.2. Imagine you are a professional thief who plans to rob houses along a street of &lt;math&gt;n&lt;/math&gt; homes. You know the loot at house &lt;math&gt;i&lt;/math&gt; is worth &lt;math&gt;m_i&lt;/math&gt;, for &lt;math&gt;1 \le i \le n&lt;/math&gt;, but you cannot rob neighboring houses because their connected security systems will automatically contact the police if two adjacent houses are broken into. Give an efficient algorithm to determine the maximum amount of money you can steal without alerting the police.


:[[10.3]]. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible mixes (1s,2s,3s) of scoring add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are four possible solutions: (5, 0, 0), (2, 0, 1), (1, 2, 0), and (0, 1, 1).
[[10.3|Solution]]


:10.4. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible scoring sequences add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are thirteen possible sequences, including 1-2-1-1, 3-2, and 1-1-1-1-1.


:[[10.5]]. Given an &lt;math&gt;s * t&lt;/math&gt; grid filled with non-negative numbers, find a path from top left to bottom right that minimizes the sum of all numbers along its path. You can only move either down or right at any point in time.
::(a) Give a solution based on Dijkstra’s algorithm. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
::(b) Give a solution based on dynamic programming. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
[[10.5|Solution]]

===Edit Distance===

:10.6. Typists often make transposition errors exchanging neighboring characters, such as typing “setve” for “steve.” This requires two substitutions to fix under the conventional definition of edit distance.
:Incorporate a swap operation into our edit distance function, so that such neighboring transposition errors can be fixed at the cost of one operation.


:[[10.7]]. Suppose you are given three strings of characters: &lt;math&gt;X&lt;/math&gt;, &lt;math&gt;Y&lt;/math&gt;, and &lt;math&gt;Z&lt;/math&gt;, where &lt;math&gt;|X| = n&lt;/math&gt;, &lt;math&gt;|Y| = m&lt;/math&gt;, and &lt;math&gt;|Z| = n + m&lt;/math&gt;. &lt;math&gt;Z&lt;/math&gt; is said to be a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; iff &lt;math&gt;Z&lt;/math&gt; can be formed by interleaving the characters from &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; in a way that maintains the left-to-right ordering of the characters from each string. 
:(a) Show that cchocohilaptes is a shuffle of chocolate and chips, but chocochilatspe is not.
:(b) Give an efficient dynamic programming algorithm that determines whether &lt;math&gt;Z&lt;/math&gt; is a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt;. (Hint: the values of the dynamic programming matrix you construct should be Boolean, not numeric.)
[[10.7|Solution]]


:10.8. The longest common substring (not subsequence) of two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; is the longest string that appears as a run of consecutive letters in both strings. For example, the longest common substring of photograph and tomography is ograph.
:(a) Let &lt;math&gt;n = |X|&lt;/math&gt; and &lt;math&gt;m = |Y|&lt;/math&gt;. Give a &lt;math&gt;\Theta (nm)&lt;/math&gt; dynamic programming algorithm for longest common substring based on the longest common subsequence/edit distance algorithm.
:(b) Give a simpler &lt;math&gt;\Theta (nm)&lt;/math&gt; algorithm that does not rely on dynamic programming.


:[[10.9]]. The ''longest common subsequence (LCS)'' of two sequences &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the longest sequence &lt;math&gt;L&lt;/math&gt; such that &lt;math&gt;L&lt;/math&gt; is a subsequence of both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;. The ''shortest common supersequence (SCS)'' of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the smallest sequence &lt;math&gt;L&lt;/math&gt; such that both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; are a subsequence of &lt;math&gt;L&lt;/math&gt;.
:(a) Give efficient algorithms to find the LCS and SCS of two given sequences.
:(b) Let &lt;math&gt;d(T, P)&lt;/math&gt; be the minimum edit distance between &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; when no substitutions are allowed (i.e., the only changes are character insertion and deletion). Prove that &lt;math&gt;d(T, P) = |SCS(T, P)| - |LCS(T, P)|&lt;/math&gt; where &lt;math&gt;|SCS(T, P)| (|LCS(T, P)|)&lt;/math&gt; is the size of the shortest SCS (longest LCS) of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;.
[[10.9|Solution]]


:10.10. Suppose you are given &lt;math&gt;n&lt;/math&gt; poker chips stacked in two stacks, where the edges of all chips can be seen. Each chip is one of three colors. A turn consists of choosing a color and removing all chips of that color from the tops of the stacks. The goal is to minimize the number of turns until the chips are gone. 
:For example, consider the stacks &lt;math&gt;(RRGG, GBBB)&lt;/math&gt;. Playing red, green, and then blue suffices to clear the stacks in three moves. Give an &lt;math&gt;O(n^2)&lt;/math&gt; dynamic programming algorithm to find the best strategy for a given pair of chip piles.

===Greedy Algorithms===

:[[10.11]]. Let &lt;math&gt;P_1, P_2, . . . , P_n&lt;/math&gt; be &lt;math&gt;n&lt;/math&gt; programs to be stored on a disk with capacity &lt;math&gt;D&lt;/math&gt; megabytes. Program &lt;math&gt;P_i&lt;/math&gt; requires &lt;math&gt;s_i&lt;/math&gt; megabytes of storage. We cannot store them all because &lt;math&gt;D &lt; \sum_{i=1}^n s_i &lt;/math&gt;
:(a) Does a greedy algorithm that selects programs in order of non-decreasing &lt;math&gt;s_i&lt;/math&gt; maximize the number of programs held on the disk? Prove or give a counter-example.
:(b) Does a greedy algorithm that selects programs in order of non-increasing &lt;math&gt;s_i&lt;/math&gt; use as much of the capacity of the disk as possible? Prove or give a counter-example.
[[10.11|Solution]]


:10.12. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We seek an algorithm to make change of &lt;math&gt;n&lt;/math&gt; units using the minimum number of this country’s coins.
:(a) The greedy algorithm repeatedly selects the biggest coin no bigger than the amount to be changed and repeats until it is zero. Show that the greedy algorithm does not always use the minimum number of coins in a country whose denominations are {1, 6, 10}.
:(b) Give an efficient algorithm that correctly determines the minimum number of coins needed to make change of &lt;math&gt;n&lt;/math&gt; units using denominations &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt;. Analyze its running time.


:[[10.13]]. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We want to count how many distinct ways &lt;math&gt;C(n)&lt;/math&gt; there are to make change of &lt;math&gt;n&lt;/math&gt; units. For example, in a country whose denominations are {1, 6, 10}, &lt;math&gt;C(5) = 1&lt;/math&gt;, &lt;math&gt;C(6)&lt;/math&gt; to &lt;math&gt;C(9) = 2&lt;/math&gt;, &lt;math&gt;C(10) = 3&lt;/math&gt;, and &lt;math&gt;C(12) = 4&lt;/math&gt;.
:(a) How many ways are there to make change of 20 units from {1, 6, 10}?
:(b) Give an efficient algorithm to compute &lt;math&gt;C(n)&lt;/math&gt;, and analyze its complexity. (Hint: think in terms of computing &lt;math&gt;C(n, d)&lt;/math&gt;, the number of ways to make change of &lt;math&gt;n&lt;/math&gt; units with highest denomination &lt;math&gt;d&lt;/math&gt;. Be careful to avoid overcounting.)
[[10.13|Solution]]


:10.14. In the single-processor scheduling problem, we are given a set of &lt;math&gt;n&lt;/math&gt; jobs &lt;math&gt;J&lt;/math&gt;. Each job &lt;math&gt;i&lt;/math&gt; has a processing time &lt;math&gt;t_i&lt;/math&gt;, and a deadline &lt;math&gt;d_i&lt;/math&gt;. A feasible schedule is a permutation of the jobs such that when the jobs are performed in that order, every job is finished before its deadline. The greedy algorithm for single-processor scheduling selects the job with the earliest deadline first.
:Show that if a feasible schedule exists, then the schedule produced by this greedy algorithm is feasible.

===Number Problems===

:[[10.15]]. You are given a rod of length &lt;math&gt;n&lt;/math&gt; inches and a table of prices obtainable for rod-pieces of size &lt;math&gt;n&lt;/math&gt; or smaller. Give an efficient algorithm to find the maximum value obtainable by cutting up the rod and selling the pieces. For example, if &lt;math&gt;n=8&lt;/math&gt; and the values of different pieces are:
&lt;center&gt;&lt;math&gt;	
\begin{array}{|c|c|c|c|c|c|c|c||c|} length &amp; 1 &amp; 2 &amp; 3 &amp; 4 &amp; 5 &amp; 6 &amp; 7 &amp; 8\\
\hline
price&amp;1&amp;5&amp;8&amp;9&amp;10&amp;17&amp;17&amp;20\\
\end{array}&lt;/math&gt;
&lt;/center&gt;
:then the maximum obtainable value is 22, by cutting into pieces of lengths 2 and 6.
[[10.15|Solution]]


:10.16. Your boss has written an arithmetic expression of n terms to compute your annual bonus, but permits you to parenthesize it however you wish. Give an efficient algorithm to design the parenthesization to maximize the value. For the expression:
&lt;center&gt;&lt;math&gt;6 + 2 * 0 - 4&lt;/math&gt;&lt;/center&gt;
:there exist parenthesizations with values ranging from −32 to 2.


:[[10.17]]. Given a positive integer &lt;math&gt;n&lt;/math&gt;, find an efficient algorithm to compute the smallest number of perfect squares (e.g. 1, 4, 9, 16, . . .) that sum to &lt;math&gt;n&lt;/math&gt;. What is the running time of your algorithm?
[[10.17|Solution]]


:10.18. Given an array &lt;math&gt;A&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find an efficient algorithm to compute the largest sum of a continuous run. For &lt;math&gt;A = [-3, 2, 7, -3, 4, -2, 0, 1]&lt;/math&gt;, the largest such sum is 10, from the second through fifth positions.


:[[10.19]]. Two drivers have to divide up &lt;math&gt;m&lt;/math&gt; suitcases between them, where the weight of the &lt;math&gt;ith&lt;/math&gt; suitcase is &lt;math&gt;w_i&lt;/math&gt;. Give an efficient algorithm to divide up the loads so the two drivers carry equal weight, if possible.
[[10.19|Solution]]


:10.20. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = {s_1, s_2, . . . , s_n}&lt;/math&gt;, and a given target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; that adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, within &lt;math&gt;S = {1, 2, 5, 9, 10}&lt;/math&gt; there is a subset that adds up to &lt;math&gt;T = 22&lt;/math&gt; but not &lt;math&gt;T = 23&lt;/math&gt;.
:Give a dynamic programming algorithm for knapsack that runs in &lt;math&gt;O(nT)&lt;/math&gt; time.


:[[10.21]]. The integer partition takes a set of positive integers &lt;math&gt;S = {s_1, . . . , s_n}&lt;/math&gt; and seeks a subset &lt;math&gt;I \subset S&lt;/math&gt; such that
&lt;center&gt;&lt;math&gt; \sum_{i \in I} s_i = \sum_{i \notin I} s_i&lt;/math&gt;&lt;/center&gt;
:Let &lt;math&gt; \sum_{i \in S} s_i = M &lt;/math&gt;. Give an &lt;math&gt;O(nM)&lt;/math&gt; dynamic programming algorithm to solve the integer partition problem.
[[10.21|Solution]]


:10.22. Assume that there are n numbers (some possibly negative) on a circle, and we wish to find the maximum contiguous sum along an arc of the circle. Give an efficient algorithm for solving this problem.


:[[10.23]]. A certain string processing language allows the programmer to break a string into two pieces. It costs &lt;math&gt;n&lt;/math&gt; units of time to break a string of &lt;math&gt;n&lt;/math&gt; characters into two pieces, since this involves copying the old string. A programmer wants to break a string into many pieces, and the order in which the breaks are made can affect the total amount of time used. For example, suppose we wish to break a 20-character string after characters 3, 8, and 10. If the breaks are made in left-to-right order, then the first break costs 20 units of time, the second break costs 17 units of time, and the third break costs 12 units of time, for a total of 49 units. If the breaks are made in right-to-left order, the first break costs 20 units of time, the second break costs 10 units of time, and the third break costs 8 units of time, for a total of only 38 units.
:Give a dynamic programming algorithm that takes a list of character positions after which to break and determines the cheapest break cost in &lt;math&gt;O(n^3)&lt;/math&gt; time.
[[10.23|Solution]]


:10.24. Consider the following data compression technique. We have a table of &lt;math&gt;m&lt;/math&gt; text strings, each at most &lt;math&gt;k&lt;/math&gt; in length. We want to encode a data string &lt;math&gt;D&lt;/math&gt; of length &lt;math&gt;n&lt;/math&gt; using as few text strings as possible. For example, if our table contains &lt;math&gt;(a,ba,abab,b)&lt;/math&gt; and the data string is &lt;math&gt;bababbaababa&lt;/math&gt;, the best way to encode it is &lt;math&gt;(b,abab,ba,abab,a)-a&lt;/math&gt; total of five code words. Give an &lt;math&gt;O(nmk)&lt;/math&gt; algorithm to find the length of the best encoding. You may assume that every string has at least one encoding in terms of the table.


:[[10.25]]. The traditional world chess championship is a match of 24 games. The current champion retains the title in case the match is a tie. Each game ends in a win, loss, or draw (tie) where wins count as 1, losses as 0, and draws as &lt;math&gt;1/2&lt;/math&gt;. The players take turns playing white and black. White plays first and so has an advantage. The champion plays white in the first game. The champ has probabilities &lt;math&gt;w_w&lt;/math&gt;, &lt;math&gt;w_d&lt;/math&gt;, and &lt;math&gt;w_l&lt;/math&gt; of winning, drawing, and losing playing white, and has probabilities &lt;math&gt;b_w&lt;/math&gt;, &lt;math&gt;b_d&lt;/math&gt;, and &lt;math&gt;b_l&lt;/math&gt; of winning, drawing, and losing playing black.
:(a) Write a recurrence for the probability that the champion retains the title. Assume that there are &lt;math&gt;g&lt;/math&gt; games left to play in the match and that the champion needs to get &lt;math&gt;i&lt;/math&gt; points (which may be a multiple of &lt;math&gt;1/2&lt;/math&gt;).
:(b) Based on your recurrence, give a dynamic programming algorithm to calculate the champion’s probability of retaining the title.
:(c) Analyze its running time for an &lt;math&gt;n&lt;/math&gt; game match.
[[10.125|Solution]]


:10.26. Eggs break when dropped from great enough height. Specifically, there must be a floor &lt;math&gt;f&lt;/math&gt; in any sufficiently tall building such that an egg dropped from the &lt;math&gt;f&lt;/math&gt;th floor breaks, but one dropped from the &lt;math&gt;(f - 1)&lt;/math&gt;st floor will not. If the egg always breaks, then &lt;math&gt;f = 1&lt;/math&gt;. If the egg never breaks, then &lt;math&gt;f = n + 1&lt;/math&gt;. 
:You seek to find the critical floor &lt;math&gt;f&lt;/math&gt; using an &lt;math&gt;n-floor&lt;/math&gt; building. The only operation you can perform is to drop an egg off some floor and see what happens. You start out with &lt;math&gt;k&lt;/math&gt; eggs, and seek to make as few drops as possible. Broken eggs cannot be reused. Let &lt;math&gt;E(k, n)&lt;/math&gt; be the minimum number of egg drops that will always suffice.
:(a) Show that &lt;math&gt;E(1, n) = n&lt;/math&gt;.
:(b) Show that &lt;math&gt;E(k, n) = \Theta (n^{1/k})&lt;/math&gt;.
:(c) Find a recurrence for &lt;math&gt;E(k, n)&lt;/math&gt;. What is the running time of the dynamic program to find &lt;math&gt;E(k, n)&lt;/math&gt;?

===Graphing Problem===

:[[10.27]]. Consider a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. 
:Unfortunately, the city has bad neighborhoods, whose intersections we do not want to walk in. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is in a neighborhood to avoid.
:(a) Give an example of the contents of bad such that there is no path across the grid avoiding bad neighborhoods.
:(b) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find a path across the grid that avoids bad neighborhoods.
:(c) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find the shortest path across the grid that avoids bad neighborhoods. You may assume that all blocks are of equal length. For partial credit, give an &lt;math&gt;O(X^2Y^2)&lt;/math&gt; algorithm.
[[10.27|Solution]]


:10.28. Consider the same situation as the previous problem. We have a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is somewhere we want to avoid.
:If there were no bad neighborhoods to contend with, the shortest path across the grid would have length &lt;math&gt;(X - 1) + (Y - 1)&lt;/math&gt; blocks, and indeed there would be many such paths across the grid. Each path would consist of only rightward and downward moves.
:Give an algorithm that takes the array bad and returns the number of safe paths of length &lt;math&gt;X + Y - 2&lt;/math&gt;. For full credit, your algorithm must run in &lt;math&gt;O(XY)&lt;/math&gt;.


:[[10.29]]. You seek to create a stack out of &lt;math&gt;n&lt;/math&gt; boxes, where box &lt;math&gt;i&lt;/math&gt; has width &lt;math&gt;w_i&lt;/math&gt;, height &lt;math&gt;h_i&lt;/math&gt;, and depth &lt;math&gt;d_i&lt;/math&gt;. The boxes cannot be rotated, and can only be stacked on top of one another when each box in the stack is strictly larger than the box above it in width, height, and depth. Give an efficient algorithm to construct the tallest possible stack, where the height is the sum of the heights of each box in the stack.
[[10.29|Solution]]

===Design Problems===

:10.30. Consider the problem of storing &lt;math&gt;n&lt;/math&gt; books on shelves in a library. The order of the books is fixed by the cataloging system and so cannot be rearranged. Therefore, we can speak of a book &lt;math&gt;b_i&lt;/math&gt;, where &lt;math&gt;1 \leq i \leq n&lt;/math&gt;, that has a thickness &lt;math&gt;t_i&lt;/math&gt; and height &lt;math&gt;h_i&lt;/math&gt;. The length of each bookshelf at this library is &lt;math&gt;L&lt;/math&gt;.
:Suppose all the books have the same height &lt;math&gt;h&lt;/math&gt; (i.e., &lt;math&gt;h = h_i&lt;/math&gt; for all &lt;math&gt;i&lt;/math&gt;) and the shelves are all separated by a distance greater than &lt;math&gt;h&lt;/math&gt;, so any book fits on any shelf. The greedy algorithm would fill the first shelf with as many books as we can until we get the smallest &lt;math&gt;i&lt;/math&gt; such that &lt;math&gt;b_i&lt;/math&gt; does not fit, and then repeat with subsequent shelves. Show that the greedy algorithm always finds the book placement that uses the minimum number of shelves, and analyze its time complexity.


:[[10.31]]. This is a generalization of the previous problem. Now consider the case where the height of the books is not constant, but we have the freedom to adjust the height of each shelf to that of the tallest book on the shelf. Here the cost of a particular layout is the sum of the heights of the largest book on each shelf.
:#Give an example to show that the greedy algorithm of stuffing each shelf as full as possible does not always give the minimum overall height.
:#Give an algorithm for this problem, and analyze its time complexity. (Hint: use dynamic programming.)
[[10.31|Solution]]


:10.32. Consider a linear keyboard of lowercase letters and numbers, where the left-most 26 keys are the letters A–Z in order, followed by the digits 0–9 in order, followed by the 30 punctuation characters in a prescribed order, and ended on a blank. Assume you start with your left index finger on the “A” and your right index finger on the blank.
:Give a dynamic programming algorithm that finds the most efficient way to type a given text of length &lt;math&gt;n&lt;/math&gt;, in terms of minimizing total movement of the fingers involved. For the text &lt;math&gt;ABABABAB . . . ABAB&lt;/math&gt;, this would involve shifting both fingers all the way to the left side of the keyboard. Analyze the complexity of your algorithm as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;, the number of keys on the keyboard.


:[[10.33]]. You have come back from the future with an array &lt;math&gt;G&lt;/math&gt;, where &lt;math&gt;G[i]&lt;/math&gt; tells you the price of Google stock &lt;math&gt;i&lt;/math&gt; days from now, for &lt;math&gt;1 \leq i \leq n&lt;/math&gt;. You seek to use this information to maximize your profit, but are only permitted to complete at most one transaction (i.e. either buy one or sell one share of the stock) per day. Design an efficient algorithm to construct the buy–sell sequence to maximize your profit. Note that you cannot sell a share unless you currently own one.
[[10.33|Solution]]


:10.34. You are given a string of &lt;math&gt;n&lt;/math&gt; characters &lt;math&gt;S = s_1 . . . s_n&lt;/math&gt;, which you believe to be a compressed text document in which all spaces have been removed, like '''itwasthebestoftimes'''.
:(a) You seek to reconstruct the document using a dictionary, which is available in the form of a Boolean function &lt;math&gt;dict(w)&lt;/math&gt;, where &lt;math&gt;dict(w)&lt;/math&gt; is true iff string &lt;math&gt;w&lt;/math&gt; is a valid word in the language. Give an &lt;math&gt;O(n^2)&lt;/math&gt; algorithm to determine whether string &lt;math&gt;S&lt;/math&gt; can be reconstituted as a sequence of valid words, assuming calls to &lt;math&gt;dict(w &lt;/math&gt; take unit time.
:(b) Now assume you are given the dictionary as a set of &lt;math&gt;m&lt;/math&gt; words each of length at most l. Give an efficient algorithm to determine whether string &lt;math&gt;S&lt;/math&gt; can be reconstituted as a sequence of valid words, and its running time.


:[[10.35]]. Consider the following two-player game, where you seek to get the biggest score. You start with an n-digit integer &lt;math&gt;N&lt;/math&gt;. With each move, you get to take either the first digit or the last digit from what is left of &lt;math&gt;N&lt;/math&gt;, and add that to your score, with your opponent then doing the same thing to the now smaller number. You continue taking turns removing digits until none are left. Give an efficient algorithm that finds the best possible score that the first player can get for a given digit string &lt;math&gt;N&lt;/math&gt;, assuming the second player is as smart as can be.
[[10.35|Solution]]


:10.36. Given an array of &lt;math&gt;n&lt;/math&gt; real numbers, consider the problem of finding the maximum sum in any contiguous subarray of the input. For example, in the array
&lt;center&gt;&lt;math&gt;[31, -41, 59, 26, -53, 58, 97, -93, -23, 84]&lt;/math&gt;&lt;/center&gt;
:the maximum is achieved by summing the third through seventh elements, where 59 + 26 + (−53) + 58 + 97 = 187. When all numbers are positive, the entire array is the answer, while when all numbers are negative, the empty array maximizes the total at 0.
#Give a simple and clear &lt;math&gt; \Theta (n^2)&lt;/math&gt;-time algorithm to find the maximum contiguous subarray.
#Now give a &lt;math&gt;\Theta (n)&lt;/math&gt;-time dynamic programming algorithm for this problem. To get partial credit, you may instead give a correct &lt;math&gt;O(n log n)&lt;/math&gt; divide-and-conquer algorithm.


:[[10.37]]


:10.38. Let α and β be constants. Assume that it costs α to go left in a binary search tree, and β to go right. Devise an algorithm that builds a tree with optimal expected query cost, given keys &lt;math&gt;k_1, . . . , k_n&lt;/math&gt; and the probabilities that each will be searched &lt;math&gt;p_1, . . . , p_n&lt;/math&gt;.

===Interview Problems===

:[[10.39]]. Given a set of coin denominations, find the minimum number of coins to make a certain amount of change.
[[10.39|Solution]]


:10.40. You are given an array of n numbers, each of which may be positive, negative, or zero. Give an efficient algorithm to identify the index positions &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; to obtain the maximum sum of the &lt;math&gt;i&lt;/math&gt;th through &lt;math&gt;j&lt;/math&gt;th numbers.


:[[10.41]]. Observe that when you cut a character out of a magazine, the character on the reverse side of the page is also removed. Give an algorithm to determine whether you can generate a given string by pasting cutouts from a given magazine. Assume that you are given a function that will identify the character and its position on the reverse side of the page for any given character position.
[[10.41|Solution]]


Back to [[Chapter List]]</text>
      <sha1>n8537tek1n16ays7di77pzn0v0oo6qw</sha1>
    </revision>
    <revision>
      <id>388</id>
      <parentid>379</parentid>
      <timestamp>2020-09-21T13:42:15Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Number Problems */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="23702">=Dynamic Programming=

===Elementary Recurrences===

:[[10.1]]. Up to &lt;math&gt;k&lt;/math&gt; steps in a single bound! A child is running up a staircase with &lt;math&gt;n&lt;/math&gt; steps and can hop between 1 and &lt;math&gt;k&lt;/math&gt; steps at a time. Design an algorithm to count how many possible ways the child can run up the stairs, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. What is the running time of your algorithm?
[[10.1|Solution]]


:10.2. Imagine you are a professional thief who plans to rob houses along a street of &lt;math&gt;n&lt;/math&gt; homes. You know the loot at house &lt;math&gt;i&lt;/math&gt; is worth &lt;math&gt;m_i&lt;/math&gt;, for &lt;math&gt;1 \le i \le n&lt;/math&gt;, but you cannot rob neighboring houses because their connected security systems will automatically contact the police if two adjacent houses are broken into. Give an efficient algorithm to determine the maximum amount of money you can steal without alerting the police.


:[[10.3]]. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible mixes (1s,2s,3s) of scoring add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are four possible solutions: (5, 0, 0), (2, 0, 1), (1, 2, 0), and (0, 1, 1).
[[10.3|Solution]]


:10.4. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible scoring sequences add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are thirteen possible sequences, including 1-2-1-1, 3-2, and 1-1-1-1-1.


:[[10.5]]. Given an &lt;math&gt;s * t&lt;/math&gt; grid filled with non-negative numbers, find a path from top left to bottom right that minimizes the sum of all numbers along its path. You can only move either down or right at any point in time.
::(a) Give a solution based on Dijkstra’s algorithm. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
::(b) Give a solution based on dynamic programming. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
[[10.5|Solution]]

===Edit Distance===

:10.6. Typists often make transposition errors exchanging neighboring characters, such as typing “setve” for “steve.” This requires two substitutions to fix under the conventional definition of edit distance.
:Incorporate a swap operation into our edit distance function, so that such neighboring transposition errors can be fixed at the cost of one operation.


:[[10.7]]. Suppose you are given three strings of characters: &lt;math&gt;X&lt;/math&gt;, &lt;math&gt;Y&lt;/math&gt;, and &lt;math&gt;Z&lt;/math&gt;, where &lt;math&gt;|X| = n&lt;/math&gt;, &lt;math&gt;|Y| = m&lt;/math&gt;, and &lt;math&gt;|Z| = n + m&lt;/math&gt;. &lt;math&gt;Z&lt;/math&gt; is said to be a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; iff &lt;math&gt;Z&lt;/math&gt; can be formed by interleaving the characters from &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; in a way that maintains the left-to-right ordering of the characters from each string. 
:(a) Show that cchocohilaptes is a shuffle of chocolate and chips, but chocochilatspe is not.
:(b) Give an efficient dynamic programming algorithm that determines whether &lt;math&gt;Z&lt;/math&gt; is a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt;. (Hint: the values of the dynamic programming matrix you construct should be Boolean, not numeric.)
[[10.7|Solution]]


:10.8. The longest common substring (not subsequence) of two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; is the longest string that appears as a run of consecutive letters in both strings. For example, the longest common substring of photograph and tomography is ograph.
:(a) Let &lt;math&gt;n = |X|&lt;/math&gt; and &lt;math&gt;m = |Y|&lt;/math&gt;. Give a &lt;math&gt;\Theta (nm)&lt;/math&gt; dynamic programming algorithm for longest common substring based on the longest common subsequence/edit distance algorithm.
:(b) Give a simpler &lt;math&gt;\Theta (nm)&lt;/math&gt; algorithm that does not rely on dynamic programming.


:[[10.9]]. The ''longest common subsequence (LCS)'' of two sequences &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the longest sequence &lt;math&gt;L&lt;/math&gt; such that &lt;math&gt;L&lt;/math&gt; is a subsequence of both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;. The ''shortest common supersequence (SCS)'' of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the smallest sequence &lt;math&gt;L&lt;/math&gt; such that both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; are a subsequence of &lt;math&gt;L&lt;/math&gt;.
:(a) Give efficient algorithms to find the LCS and SCS of two given sequences.
:(b) Let &lt;math&gt;d(T, P)&lt;/math&gt; be the minimum edit distance between &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; when no substitutions are allowed (i.e., the only changes are character insertion and deletion). Prove that &lt;math&gt;d(T, P) = |SCS(T, P)| - |LCS(T, P)|&lt;/math&gt; where &lt;math&gt;|SCS(T, P)| (|LCS(T, P)|)&lt;/math&gt; is the size of the shortest SCS (longest LCS) of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;.
[[10.9|Solution]]


:10.10. Suppose you are given &lt;math&gt;n&lt;/math&gt; poker chips stacked in two stacks, where the edges of all chips can be seen. Each chip is one of three colors. A turn consists of choosing a color and removing all chips of that color from the tops of the stacks. The goal is to minimize the number of turns until the chips are gone. 
:For example, consider the stacks &lt;math&gt;(RRGG, GBBB)&lt;/math&gt;. Playing red, green, and then blue suffices to clear the stacks in three moves. Give an &lt;math&gt;O(n^2)&lt;/math&gt; dynamic programming algorithm to find the best strategy for a given pair of chip piles.

===Greedy Algorithms===

:[[10.11]]. Let &lt;math&gt;P_1, P_2, . . . , P_n&lt;/math&gt; be &lt;math&gt;n&lt;/math&gt; programs to be stored on a disk with capacity &lt;math&gt;D&lt;/math&gt; megabytes. Program &lt;math&gt;P_i&lt;/math&gt; requires &lt;math&gt;s_i&lt;/math&gt; megabytes of storage. We cannot store them all because &lt;math&gt;D &lt; \sum_{i=1}^n s_i &lt;/math&gt;
:(a) Does a greedy algorithm that selects programs in order of non-decreasing &lt;math&gt;s_i&lt;/math&gt; maximize the number of programs held on the disk? Prove or give a counter-example.
:(b) Does a greedy algorithm that selects programs in order of non-increasing &lt;math&gt;s_i&lt;/math&gt; use as much of the capacity of the disk as possible? Prove or give a counter-example.
[[10.11|Solution]]


:10.12. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We seek an algorithm to make change of &lt;math&gt;n&lt;/math&gt; units using the minimum number of this country’s coins.
:(a) The greedy algorithm repeatedly selects the biggest coin no bigger than the amount to be changed and repeats until it is zero. Show that the greedy algorithm does not always use the minimum number of coins in a country whose denominations are {1, 6, 10}.
:(b) Give an efficient algorithm that correctly determines the minimum number of coins needed to make change of &lt;math&gt;n&lt;/math&gt; units using denominations &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt;. Analyze its running time.


:[[10.13]]. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We want to count how many distinct ways &lt;math&gt;C(n)&lt;/math&gt; there are to make change of &lt;math&gt;n&lt;/math&gt; units. For example, in a country whose denominations are {1, 6, 10}, &lt;math&gt;C(5) = 1&lt;/math&gt;, &lt;math&gt;C(6)&lt;/math&gt; to &lt;math&gt;C(9) = 2&lt;/math&gt;, &lt;math&gt;C(10) = 3&lt;/math&gt;, and &lt;math&gt;C(12) = 4&lt;/math&gt;.
:(a) How many ways are there to make change of 20 units from {1, 6, 10}?
:(b) Give an efficient algorithm to compute &lt;math&gt;C(n)&lt;/math&gt;, and analyze its complexity. (Hint: think in terms of computing &lt;math&gt;C(n, d)&lt;/math&gt;, the number of ways to make change of &lt;math&gt;n&lt;/math&gt; units with highest denomination &lt;math&gt;d&lt;/math&gt;. Be careful to avoid overcounting.)
[[10.13|Solution]]


:10.14. In the single-processor scheduling problem, we are given a set of &lt;math&gt;n&lt;/math&gt; jobs &lt;math&gt;J&lt;/math&gt;. Each job &lt;math&gt;i&lt;/math&gt; has a processing time &lt;math&gt;t_i&lt;/math&gt;, and a deadline &lt;math&gt;d_i&lt;/math&gt;. A feasible schedule is a permutation of the jobs such that when the jobs are performed in that order, every job is finished before its deadline. The greedy algorithm for single-processor scheduling selects the job with the earliest deadline first.
:Show that if a feasible schedule exists, then the schedule produced by this greedy algorithm is feasible.

===Number Problems===

:[[10.15]]. You are given a rod of length &lt;math&gt;n&lt;/math&gt; inches and a table of prices obtainable for rod-pieces of size &lt;math&gt;n&lt;/math&gt; or smaller. Give an efficient algorithm to find the maximum value obtainable by cutting up the rod and selling the pieces. For example, if &lt;math&gt;n=8&lt;/math&gt; and the values of different pieces are:
&lt;center&gt;&lt;math&gt;	
\begin{array}{|c|c|c|c|c|c|c|c||c|} length &amp; 1 &amp; 2 &amp; 3 &amp; 4 &amp; 5 &amp; 6 &amp; 7 &amp; 8\\
\hline
price&amp;1&amp;5&amp;8&amp;9&amp;10&amp;17&amp;17&amp;20\\
\end{array}&lt;/math&gt;
&lt;/center&gt;
:then the maximum obtainable value is 22, by cutting into pieces of lengths 2 and 6.
[[10.15|Solution]]


:10.16. Your boss has written an arithmetic expression of n terms to compute your annual bonus, but permits you to parenthesize it however you wish. Give an efficient algorithm to design the parenthesization to maximize the value. For the expression:
&lt;center&gt;&lt;math&gt;6 + 2 * 0 - 4&lt;/math&gt;&lt;/center&gt;
:there exist parenthesizations with values ranging from −32 to 2.


:[[10.17]]. Given a positive integer &lt;math&gt;n&lt;/math&gt;, find an efficient algorithm to compute the smallest number of perfect squares (e.g. 1, 4, 9, 16, . . .) that sum to &lt;math&gt;n&lt;/math&gt;. What is the running time of your algorithm?
[[10.17|Solution]]


:10.18. Given an array &lt;math&gt;A&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find an efficient algorithm to compute the largest sum of a continuous run. For &lt;math&gt;A = [-3, 2, 7, -3, 4, -2, 0, 1]&lt;/math&gt;, the largest such sum is 10, from the second through fifth positions.


:[[10.19]]. Two drivers have to divide up &lt;math&gt;m&lt;/math&gt; suitcases between them, where the weight of the &lt;math&gt;ith&lt;/math&gt; suitcase is &lt;math&gt;w_i&lt;/math&gt;. Give an efficient algorithm to divide up the loads so the two drivers carry equal weight, if possible.
[[10.19|Solution]]


:10.20. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = {s_1, s_2, . . . , s_n}&lt;/math&gt;, and a given target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; that adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, within &lt;math&gt;S = {1, 2, 5, 9, 10}&lt;/math&gt; there is a subset that adds up to &lt;math&gt;T = 22&lt;/math&gt; but not &lt;math&gt;T = 23&lt;/math&gt;.
:Give a dynamic programming algorithm for knapsack that runs in &lt;math&gt;O(nT)&lt;/math&gt; time.


:[[10.21]]. The integer partition takes a set of positive integers &lt;math&gt;S = {s_1, . . . , s_n}&lt;/math&gt; and seeks a subset &lt;math&gt;I \subset S&lt;/math&gt; such that
&lt;center&gt;&lt;math&gt; \sum_{i \in I} s_i = \sum_{i \notin I} s_i&lt;/math&gt;&lt;/center&gt;
:Let &lt;math&gt; \sum_{i \in S} s_i = M &lt;/math&gt;. Give an &lt;math&gt;O(nM)&lt;/math&gt; dynamic programming algorithm to solve the integer partition problem.
[[10.21|Solution]]


:10.22. Assume that there are n numbers (some possibly negative) on a circle, and we wish to find the maximum contiguous sum along an arc of the circle. Give an efficient algorithm for solving this problem.


:[[10.23]]. A certain string processing language allows the programmer to break a string into two pieces. It costs &lt;math&gt;n&lt;/math&gt; units of time to break a string of &lt;math&gt;n&lt;/math&gt; characters into two pieces, since this involves copying the old string. A programmer wants to break a string into many pieces, and the order in which the breaks are made can affect the total amount of time used. For example, suppose we wish to break a 20-character string after characters 3, 8, and 10. If the breaks are made in left-to-right order, then the first break costs 20 units of time, the second break costs 17 units of time, and the third break costs 12 units of time, for a total of 49 units. If the breaks are made in right-to-left order, the first break costs 20 units of time, the second break costs 10 units of time, and the third break costs 8 units of time, for a total of only 38 units.
:Give a dynamic programming algorithm that takes a list of character positions after which to break and determines the cheapest break cost in &lt;math&gt;O(n^3)&lt;/math&gt; time.
[[10.23|Solution]]


:10.24. Consider the following data compression technique. We have a table of &lt;math&gt;m&lt;/math&gt; text strings, each at most &lt;math&gt;k&lt;/math&gt; in length. We want to encode a data string &lt;math&gt;D&lt;/math&gt; of length &lt;math&gt;n&lt;/math&gt; using as few text strings as possible. For example, if our table contains &lt;math&gt;(a,ba,abab,b)&lt;/math&gt; and the data string is &lt;math&gt;bababbaababa&lt;/math&gt;, the best way to encode it is &lt;math&gt;(b,abab,ba,abab,a)-a&lt;/math&gt; total of five code words. Give an &lt;math&gt;O(nmk)&lt;/math&gt; algorithm to find the length of the best encoding. You may assume that every string has at least one encoding in terms of the table.


:[[10.25]]. The traditional world chess championship is a match of 24 games. The current champion retains the title in case the match is a tie. Each game ends in a win, loss, or draw (tie) where wins count as 1, losses as 0, and draws as &lt;math&gt;1/2&lt;/math&gt;. The players take turns playing white and black. White plays first and so has an advantage. The champion plays white in the first game. The champ has probabilities &lt;math&gt;w_w&lt;/math&gt;, &lt;math&gt;w_d&lt;/math&gt;, and &lt;math&gt;w_l&lt;/math&gt; of winning, drawing, and losing playing white, and has probabilities &lt;math&gt;b_w&lt;/math&gt;, &lt;math&gt;b_d&lt;/math&gt;, and &lt;math&gt;b_l&lt;/math&gt; of winning, drawing, and losing playing black.
:(a) Write a recurrence for the probability that the champion retains the title. Assume that there are &lt;math&gt;g&lt;/math&gt; games left to play in the match and that the champion needs to get &lt;math&gt;i&lt;/math&gt; points (which may be a multiple of &lt;math&gt;1/2&lt;/math&gt;).
:(b) Based on your recurrence, give a dynamic programming algorithm to calculate the champion’s probability of retaining the title.
:(c) Analyze its running time for an &lt;math&gt;n&lt;/math&gt; game match.
[[10.25|Solution]]


:10.26. Eggs break when dropped from great enough height. Specifically, there must be a floor &lt;math&gt;f&lt;/math&gt; in any sufficiently tall building such that an egg dropped from the &lt;math&gt;f&lt;/math&gt;th floor breaks, but one dropped from the &lt;math&gt;(f - 1)&lt;/math&gt;st floor will not. If the egg always breaks, then &lt;math&gt;f = 1&lt;/math&gt;. If the egg never breaks, then &lt;math&gt;f = n + 1&lt;/math&gt;. 
:You seek to find the critical floor &lt;math&gt;f&lt;/math&gt; using an &lt;math&gt;n-floor&lt;/math&gt; building. The only operation you can perform is to drop an egg off some floor and see what happens. You start out with &lt;math&gt;k&lt;/math&gt; eggs, and seek to make as few drops as possible. Broken eggs cannot be reused. Let &lt;math&gt;E(k, n)&lt;/math&gt; be the minimum number of egg drops that will always suffice.
:(a) Show that &lt;math&gt;E(1, n) = n&lt;/math&gt;.
:(b) Show that &lt;math&gt;E(k, n) = \Theta (n^{1/k})&lt;/math&gt;.
:(c) Find a recurrence for &lt;math&gt;E(k, n)&lt;/math&gt;. What is the running time of the dynamic program to find &lt;math&gt;E(k, n)&lt;/math&gt;?

===Graphing Problem===

:[[10.27]]. Consider a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. 
:Unfortunately, the city has bad neighborhoods, whose intersections we do not want to walk in. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is in a neighborhood to avoid.
:(a) Give an example of the contents of bad such that there is no path across the grid avoiding bad neighborhoods.
:(b) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find a path across the grid that avoids bad neighborhoods.
:(c) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find the shortest path across the grid that avoids bad neighborhoods. You may assume that all blocks are of equal length. For partial credit, give an &lt;math&gt;O(X^2Y^2)&lt;/math&gt; algorithm.
[[10.27|Solution]]


:10.28. Consider the same situation as the previous problem. We have a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is somewhere we want to avoid.
:If there were no bad neighborhoods to contend with, the shortest path across the grid would have length &lt;math&gt;(X - 1) + (Y - 1)&lt;/math&gt; blocks, and indeed there would be many such paths across the grid. Each path would consist of only rightward and downward moves.
:Give an algorithm that takes the array bad and returns the number of safe paths of length &lt;math&gt;X + Y - 2&lt;/math&gt;. For full credit, your algorithm must run in &lt;math&gt;O(XY)&lt;/math&gt;.


:[[10.29]]. You seek to create a stack out of &lt;math&gt;n&lt;/math&gt; boxes, where box &lt;math&gt;i&lt;/math&gt; has width &lt;math&gt;w_i&lt;/math&gt;, height &lt;math&gt;h_i&lt;/math&gt;, and depth &lt;math&gt;d_i&lt;/math&gt;. The boxes cannot be rotated, and can only be stacked on top of one another when each box in the stack is strictly larger than the box above it in width, height, and depth. Give an efficient algorithm to construct the tallest possible stack, where the height is the sum of the heights of each box in the stack.
[[10.29|Solution]]

===Design Problems===

:10.30. Consider the problem of storing &lt;math&gt;n&lt;/math&gt; books on shelves in a library. The order of the books is fixed by the cataloging system and so cannot be rearranged. Therefore, we can speak of a book &lt;math&gt;b_i&lt;/math&gt;, where &lt;math&gt;1 \leq i \leq n&lt;/math&gt;, that has a thickness &lt;math&gt;t_i&lt;/math&gt; and height &lt;math&gt;h_i&lt;/math&gt;. The length of each bookshelf at this library is &lt;math&gt;L&lt;/math&gt;.
:Suppose all the books have the same height &lt;math&gt;h&lt;/math&gt; (i.e., &lt;math&gt;h = h_i&lt;/math&gt; for all &lt;math&gt;i&lt;/math&gt;) and the shelves are all separated by a distance greater than &lt;math&gt;h&lt;/math&gt;, so any book fits on any shelf. The greedy algorithm would fill the first shelf with as many books as we can until we get the smallest &lt;math&gt;i&lt;/math&gt; such that &lt;math&gt;b_i&lt;/math&gt; does not fit, and then repeat with subsequent shelves. Show that the greedy algorithm always finds the book placement that uses the minimum number of shelves, and analyze its time complexity.


:[[10.31]]. This is a generalization of the previous problem. Now consider the case where the height of the books is not constant, but we have the freedom to adjust the height of each shelf to that of the tallest book on the shelf. Here the cost of a particular layout is the sum of the heights of the largest book on each shelf.
:#Give an example to show that the greedy algorithm of stuffing each shelf as full as possible does not always give the minimum overall height.
:#Give an algorithm for this problem, and analyze its time complexity. (Hint: use dynamic programming.)
[[10.31|Solution]]


:10.32. Consider a linear keyboard of lowercase letters and numbers, where the left-most 26 keys are the letters A–Z in order, followed by the digits 0–9 in order, followed by the 30 punctuation characters in a prescribed order, and ended on a blank. Assume you start with your left index finger on the “A” and your right index finger on the blank.
:Give a dynamic programming algorithm that finds the most efficient way to type a given text of length &lt;math&gt;n&lt;/math&gt;, in terms of minimizing total movement of the fingers involved. For the text &lt;math&gt;ABABABAB . . . ABAB&lt;/math&gt;, this would involve shifting both fingers all the way to the left side of the keyboard. Analyze the complexity of your algorithm as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;, the number of keys on the keyboard.


:[[10.33]]. You have come back from the future with an array &lt;math&gt;G&lt;/math&gt;, where &lt;math&gt;G[i]&lt;/math&gt; tells you the price of Google stock &lt;math&gt;i&lt;/math&gt; days from now, for &lt;math&gt;1 \leq i \leq n&lt;/math&gt;. You seek to use this information to maximize your profit, but are only permitted to complete at most one transaction (i.e. either buy one or sell one share of the stock) per day. Design an efficient algorithm to construct the buy–sell sequence to maximize your profit. Note that you cannot sell a share unless you currently own one.
[[10.33|Solution]]


:10.34. You are given a string of &lt;math&gt;n&lt;/math&gt; characters &lt;math&gt;S = s_1 . . . s_n&lt;/math&gt;, which you believe to be a compressed text document in which all spaces have been removed, like '''itwasthebestoftimes'''.
:(a) You seek to reconstruct the document using a dictionary, which is available in the form of a Boolean function &lt;math&gt;dict(w)&lt;/math&gt;, where &lt;math&gt;dict(w)&lt;/math&gt; is true iff string &lt;math&gt;w&lt;/math&gt; is a valid word in the language. Give an &lt;math&gt;O(n^2)&lt;/math&gt; algorithm to determine whether string &lt;math&gt;S&lt;/math&gt; can be reconstituted as a sequence of valid words, assuming calls to &lt;math&gt;dict(w &lt;/math&gt; take unit time.
:(b) Now assume you are given the dictionary as a set of &lt;math&gt;m&lt;/math&gt; words each of length at most l. Give an efficient algorithm to determine whether string &lt;math&gt;S&lt;/math&gt; can be reconstituted as a sequence of valid words, and its running time.


:[[10.35]]. Consider the following two-player game, where you seek to get the biggest score. You start with an n-digit integer &lt;math&gt;N&lt;/math&gt;. With each move, you get to take either the first digit or the last digit from what is left of &lt;math&gt;N&lt;/math&gt;, and add that to your score, with your opponent then doing the same thing to the now smaller number. You continue taking turns removing digits until none are left. Give an efficient algorithm that finds the best possible score that the first player can get for a given digit string &lt;math&gt;N&lt;/math&gt;, assuming the second player is as smart as can be.
[[10.35|Solution]]


:10.36. Given an array of &lt;math&gt;n&lt;/math&gt; real numbers, consider the problem of finding the maximum sum in any contiguous subarray of the input. For example, in the array
&lt;center&gt;&lt;math&gt;[31, -41, 59, 26, -53, 58, 97, -93, -23, 84]&lt;/math&gt;&lt;/center&gt;
:the maximum is achieved by summing the third through seventh elements, where 59 + 26 + (−53) + 58 + 97 = 187. When all numbers are positive, the entire array is the answer, while when all numbers are negative, the empty array maximizes the total at 0.
#Give a simple and clear &lt;math&gt; \Theta (n^2)&lt;/math&gt;-time algorithm to find the maximum contiguous subarray.
#Now give a &lt;math&gt;\Theta (n)&lt;/math&gt;-time dynamic programming algorithm for this problem. To get partial credit, you may instead give a correct &lt;math&gt;O(n log n)&lt;/math&gt; divide-and-conquer algorithm.


:[[10.37]]


:10.38. Let α and β be constants. Assume that it costs α to go left in a binary search tree, and β to go right. Devise an algorithm that builds a tree with optimal expected query cost, given keys &lt;math&gt;k_1, . . . , k_n&lt;/math&gt; and the probabilities that each will be searched &lt;math&gt;p_1, . . . , p_n&lt;/math&gt;.

===Interview Problems===

:[[10.39]]. Given a set of coin denominations, find the minimum number of coins to make a certain amount of change.
[[10.39|Solution]]


:10.40. You are given an array of n numbers, each of which may be positive, negative, or zero. Give an efficient algorithm to identify the index positions &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; to obtain the maximum sum of the &lt;math&gt;i&lt;/math&gt;th through &lt;math&gt;j&lt;/math&gt;th numbers.


:[[10.41]]. Observe that when you cut a character out of a magazine, the character on the reverse side of the page is also removed. Give an algorithm to determine whether you can generate a given string by pasting cutouts from a given magazine. Assume that you are given a function that will identify the character and its position on the reverse side of the page for any given character position.
[[10.41|Solution]]


Back to [[Chapter List]]</text>
      <sha1>a9b38vbh2vdscnljvmyiv9t71qnb9jw</sha1>
    </revision>
    <revision>
      <id>394</id>
      <parentid>388</parentid>
      <timestamp>2020-09-21T13:48:15Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Design Problems */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24860">=Dynamic Programming=

===Elementary Recurrences===

:[[10.1]]. Up to &lt;math&gt;k&lt;/math&gt; steps in a single bound! A child is running up a staircase with &lt;math&gt;n&lt;/math&gt; steps and can hop between 1 and &lt;math&gt;k&lt;/math&gt; steps at a time. Design an algorithm to count how many possible ways the child can run up the stairs, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. What is the running time of your algorithm?
[[10.1|Solution]]


:10.2. Imagine you are a professional thief who plans to rob houses along a street of &lt;math&gt;n&lt;/math&gt; homes. You know the loot at house &lt;math&gt;i&lt;/math&gt; is worth &lt;math&gt;m_i&lt;/math&gt;, for &lt;math&gt;1 \le i \le n&lt;/math&gt;, but you cannot rob neighboring houses because their connected security systems will automatically contact the police if two adjacent houses are broken into. Give an efficient algorithm to determine the maximum amount of money you can steal without alerting the police.


:[[10.3]]. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible mixes (1s,2s,3s) of scoring add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are four possible solutions: (5, 0, 0), (2, 0, 1), (1, 2, 0), and (0, 1, 1).
[[10.3|Solution]]


:10.4. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible scoring sequences add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are thirteen possible sequences, including 1-2-1-1, 3-2, and 1-1-1-1-1.


:[[10.5]]. Given an &lt;math&gt;s * t&lt;/math&gt; grid filled with non-negative numbers, find a path from top left to bottom right that minimizes the sum of all numbers along its path. You can only move either down or right at any point in time.
::(a) Give a solution based on Dijkstra’s algorithm. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
::(b) Give a solution based on dynamic programming. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
[[10.5|Solution]]

===Edit Distance===

:10.6. Typists often make transposition errors exchanging neighboring characters, such as typing “setve” for “steve.” This requires two substitutions to fix under the conventional definition of edit distance.
:Incorporate a swap operation into our edit distance function, so that such neighboring transposition errors can be fixed at the cost of one operation.


:[[10.7]]. Suppose you are given three strings of characters: &lt;math&gt;X&lt;/math&gt;, &lt;math&gt;Y&lt;/math&gt;, and &lt;math&gt;Z&lt;/math&gt;, where &lt;math&gt;|X| = n&lt;/math&gt;, &lt;math&gt;|Y| = m&lt;/math&gt;, and &lt;math&gt;|Z| = n + m&lt;/math&gt;. &lt;math&gt;Z&lt;/math&gt; is said to be a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; iff &lt;math&gt;Z&lt;/math&gt; can be formed by interleaving the characters from &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; in a way that maintains the left-to-right ordering of the characters from each string. 
:(a) Show that cchocohilaptes is a shuffle of chocolate and chips, but chocochilatspe is not.
:(b) Give an efficient dynamic programming algorithm that determines whether &lt;math&gt;Z&lt;/math&gt; is a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt;. (Hint: the values of the dynamic programming matrix you construct should be Boolean, not numeric.)
[[10.7|Solution]]


:10.8. The longest common substring (not subsequence) of two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; is the longest string that appears as a run of consecutive letters in both strings. For example, the longest common substring of photograph and tomography is ograph.
:(a) Let &lt;math&gt;n = |X|&lt;/math&gt; and &lt;math&gt;m = |Y|&lt;/math&gt;. Give a &lt;math&gt;\Theta (nm)&lt;/math&gt; dynamic programming algorithm for longest common substring based on the longest common subsequence/edit distance algorithm.
:(b) Give a simpler &lt;math&gt;\Theta (nm)&lt;/math&gt; algorithm that does not rely on dynamic programming.


:[[10.9]]. The ''longest common subsequence (LCS)'' of two sequences &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the longest sequence &lt;math&gt;L&lt;/math&gt; such that &lt;math&gt;L&lt;/math&gt; is a subsequence of both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;. The ''shortest common supersequence (SCS)'' of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the smallest sequence &lt;math&gt;L&lt;/math&gt; such that both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; are a subsequence of &lt;math&gt;L&lt;/math&gt;.
:(a) Give efficient algorithms to find the LCS and SCS of two given sequences.
:(b) Let &lt;math&gt;d(T, P)&lt;/math&gt; be the minimum edit distance between &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; when no substitutions are allowed (i.e., the only changes are character insertion and deletion). Prove that &lt;math&gt;d(T, P) = |SCS(T, P)| - |LCS(T, P)|&lt;/math&gt; where &lt;math&gt;|SCS(T, P)| (|LCS(T, P)|)&lt;/math&gt; is the size of the shortest SCS (longest LCS) of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;.
[[10.9|Solution]]


:10.10. Suppose you are given &lt;math&gt;n&lt;/math&gt; poker chips stacked in two stacks, where the edges of all chips can be seen. Each chip is one of three colors. A turn consists of choosing a color and removing all chips of that color from the tops of the stacks. The goal is to minimize the number of turns until the chips are gone. 
:For example, consider the stacks &lt;math&gt;(RRGG, GBBB)&lt;/math&gt;. Playing red, green, and then blue suffices to clear the stacks in three moves. Give an &lt;math&gt;O(n^2)&lt;/math&gt; dynamic programming algorithm to find the best strategy for a given pair of chip piles.

===Greedy Algorithms===

:[[10.11]]. Let &lt;math&gt;P_1, P_2, . . . , P_n&lt;/math&gt; be &lt;math&gt;n&lt;/math&gt; programs to be stored on a disk with capacity &lt;math&gt;D&lt;/math&gt; megabytes. Program &lt;math&gt;P_i&lt;/math&gt; requires &lt;math&gt;s_i&lt;/math&gt; megabytes of storage. We cannot store them all because &lt;math&gt;D &lt; \sum_{i=1}^n s_i &lt;/math&gt;
:(a) Does a greedy algorithm that selects programs in order of non-decreasing &lt;math&gt;s_i&lt;/math&gt; maximize the number of programs held on the disk? Prove or give a counter-example.
:(b) Does a greedy algorithm that selects programs in order of non-increasing &lt;math&gt;s_i&lt;/math&gt; use as much of the capacity of the disk as possible? Prove or give a counter-example.
[[10.11|Solution]]


:10.12. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We seek an algorithm to make change of &lt;math&gt;n&lt;/math&gt; units using the minimum number of this country’s coins.
:(a) The greedy algorithm repeatedly selects the biggest coin no bigger than the amount to be changed and repeats until it is zero. Show that the greedy algorithm does not always use the minimum number of coins in a country whose denominations are {1, 6, 10}.
:(b) Give an efficient algorithm that correctly determines the minimum number of coins needed to make change of &lt;math&gt;n&lt;/math&gt; units using denominations &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt;. Analyze its running time.


:[[10.13]]. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We want to count how many distinct ways &lt;math&gt;C(n)&lt;/math&gt; there are to make change of &lt;math&gt;n&lt;/math&gt; units. For example, in a country whose denominations are {1, 6, 10}, &lt;math&gt;C(5) = 1&lt;/math&gt;, &lt;math&gt;C(6)&lt;/math&gt; to &lt;math&gt;C(9) = 2&lt;/math&gt;, &lt;math&gt;C(10) = 3&lt;/math&gt;, and &lt;math&gt;C(12) = 4&lt;/math&gt;.
:(a) How many ways are there to make change of 20 units from {1, 6, 10}?
:(b) Give an efficient algorithm to compute &lt;math&gt;C(n)&lt;/math&gt;, and analyze its complexity. (Hint: think in terms of computing &lt;math&gt;C(n, d)&lt;/math&gt;, the number of ways to make change of &lt;math&gt;n&lt;/math&gt; units with highest denomination &lt;math&gt;d&lt;/math&gt;. Be careful to avoid overcounting.)
[[10.13|Solution]]


:10.14. In the single-processor scheduling problem, we are given a set of &lt;math&gt;n&lt;/math&gt; jobs &lt;math&gt;J&lt;/math&gt;. Each job &lt;math&gt;i&lt;/math&gt; has a processing time &lt;math&gt;t_i&lt;/math&gt;, and a deadline &lt;math&gt;d_i&lt;/math&gt;. A feasible schedule is a permutation of the jobs such that when the jobs are performed in that order, every job is finished before its deadline. The greedy algorithm for single-processor scheduling selects the job with the earliest deadline first.
:Show that if a feasible schedule exists, then the schedule produced by this greedy algorithm is feasible.

===Number Problems===

:[[10.15]]. You are given a rod of length &lt;math&gt;n&lt;/math&gt; inches and a table of prices obtainable for rod-pieces of size &lt;math&gt;n&lt;/math&gt; or smaller. Give an efficient algorithm to find the maximum value obtainable by cutting up the rod and selling the pieces. For example, if &lt;math&gt;n=8&lt;/math&gt; and the values of different pieces are:
&lt;center&gt;&lt;math&gt;	
\begin{array}{|c|c|c|c|c|c|c|c||c|} length &amp; 1 &amp; 2 &amp; 3 &amp; 4 &amp; 5 &amp; 6 &amp; 7 &amp; 8\\
\hline
price&amp;1&amp;5&amp;8&amp;9&amp;10&amp;17&amp;17&amp;20\\
\end{array}&lt;/math&gt;
&lt;/center&gt;
:then the maximum obtainable value is 22, by cutting into pieces of lengths 2 and 6.
[[10.15|Solution]]


:10.16. Your boss has written an arithmetic expression of n terms to compute your annual bonus, but permits you to parenthesize it however you wish. Give an efficient algorithm to design the parenthesization to maximize the value. For the expression:
&lt;center&gt;&lt;math&gt;6 + 2 * 0 - 4&lt;/math&gt;&lt;/center&gt;
:there exist parenthesizations with values ranging from −32 to 2.


:[[10.17]]. Given a positive integer &lt;math&gt;n&lt;/math&gt;, find an efficient algorithm to compute the smallest number of perfect squares (e.g. 1, 4, 9, 16, . . .) that sum to &lt;math&gt;n&lt;/math&gt;. What is the running time of your algorithm?
[[10.17|Solution]]


:10.18. Given an array &lt;math&gt;A&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find an efficient algorithm to compute the largest sum of a continuous run. For &lt;math&gt;A = [-3, 2, 7, -3, 4, -2, 0, 1]&lt;/math&gt;, the largest such sum is 10, from the second through fifth positions.


:[[10.19]]. Two drivers have to divide up &lt;math&gt;m&lt;/math&gt; suitcases between them, where the weight of the &lt;math&gt;ith&lt;/math&gt; suitcase is &lt;math&gt;w_i&lt;/math&gt;. Give an efficient algorithm to divide up the loads so the two drivers carry equal weight, if possible.
[[10.19|Solution]]


:10.20. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = {s_1, s_2, . . . , s_n}&lt;/math&gt;, and a given target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; that adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, within &lt;math&gt;S = {1, 2, 5, 9, 10}&lt;/math&gt; there is a subset that adds up to &lt;math&gt;T = 22&lt;/math&gt; but not &lt;math&gt;T = 23&lt;/math&gt;.
:Give a dynamic programming algorithm for knapsack that runs in &lt;math&gt;O(nT)&lt;/math&gt; time.


:[[10.21]]. The integer partition takes a set of positive integers &lt;math&gt;S = {s_1, . . . , s_n}&lt;/math&gt; and seeks a subset &lt;math&gt;I \subset S&lt;/math&gt; such that
&lt;center&gt;&lt;math&gt; \sum_{i \in I} s_i = \sum_{i \notin I} s_i&lt;/math&gt;&lt;/center&gt;
:Let &lt;math&gt; \sum_{i \in S} s_i = M &lt;/math&gt;. Give an &lt;math&gt;O(nM)&lt;/math&gt; dynamic programming algorithm to solve the integer partition problem.
[[10.21|Solution]]


:10.22. Assume that there are n numbers (some possibly negative) on a circle, and we wish to find the maximum contiguous sum along an arc of the circle. Give an efficient algorithm for solving this problem.


:[[10.23]]. A certain string processing language allows the programmer to break a string into two pieces. It costs &lt;math&gt;n&lt;/math&gt; units of time to break a string of &lt;math&gt;n&lt;/math&gt; characters into two pieces, since this involves copying the old string. A programmer wants to break a string into many pieces, and the order in which the breaks are made can affect the total amount of time used. For example, suppose we wish to break a 20-character string after characters 3, 8, and 10. If the breaks are made in left-to-right order, then the first break costs 20 units of time, the second break costs 17 units of time, and the third break costs 12 units of time, for a total of 49 units. If the breaks are made in right-to-left order, the first break costs 20 units of time, the second break costs 10 units of time, and the third break costs 8 units of time, for a total of only 38 units.
:Give a dynamic programming algorithm that takes a list of character positions after which to break and determines the cheapest break cost in &lt;math&gt;O(n^3)&lt;/math&gt; time.
[[10.23|Solution]]


:10.24. Consider the following data compression technique. We have a table of &lt;math&gt;m&lt;/math&gt; text strings, each at most &lt;math&gt;k&lt;/math&gt; in length. We want to encode a data string &lt;math&gt;D&lt;/math&gt; of length &lt;math&gt;n&lt;/math&gt; using as few text strings as possible. For example, if our table contains &lt;math&gt;(a,ba,abab,b)&lt;/math&gt; and the data string is &lt;math&gt;bababbaababa&lt;/math&gt;, the best way to encode it is &lt;math&gt;(b,abab,ba,abab,a)-a&lt;/math&gt; total of five code words. Give an &lt;math&gt;O(nmk)&lt;/math&gt; algorithm to find the length of the best encoding. You may assume that every string has at least one encoding in terms of the table.


:[[10.25]]. The traditional world chess championship is a match of 24 games. The current champion retains the title in case the match is a tie. Each game ends in a win, loss, or draw (tie) where wins count as 1, losses as 0, and draws as &lt;math&gt;1/2&lt;/math&gt;. The players take turns playing white and black. White plays first and so has an advantage. The champion plays white in the first game. The champ has probabilities &lt;math&gt;w_w&lt;/math&gt;, &lt;math&gt;w_d&lt;/math&gt;, and &lt;math&gt;w_l&lt;/math&gt; of winning, drawing, and losing playing white, and has probabilities &lt;math&gt;b_w&lt;/math&gt;, &lt;math&gt;b_d&lt;/math&gt;, and &lt;math&gt;b_l&lt;/math&gt; of winning, drawing, and losing playing black.
:(a) Write a recurrence for the probability that the champion retains the title. Assume that there are &lt;math&gt;g&lt;/math&gt; games left to play in the match and that the champion needs to get &lt;math&gt;i&lt;/math&gt; points (which may be a multiple of &lt;math&gt;1/2&lt;/math&gt;).
:(b) Based on your recurrence, give a dynamic programming algorithm to calculate the champion’s probability of retaining the title.
:(c) Analyze its running time for an &lt;math&gt;n&lt;/math&gt; game match.
[[10.25|Solution]]


:10.26. Eggs break when dropped from great enough height. Specifically, there must be a floor &lt;math&gt;f&lt;/math&gt; in any sufficiently tall building such that an egg dropped from the &lt;math&gt;f&lt;/math&gt;th floor breaks, but one dropped from the &lt;math&gt;(f - 1)&lt;/math&gt;st floor will not. If the egg always breaks, then &lt;math&gt;f = 1&lt;/math&gt;. If the egg never breaks, then &lt;math&gt;f = n + 1&lt;/math&gt;. 
:You seek to find the critical floor &lt;math&gt;f&lt;/math&gt; using an &lt;math&gt;n-floor&lt;/math&gt; building. The only operation you can perform is to drop an egg off some floor and see what happens. You start out with &lt;math&gt;k&lt;/math&gt; eggs, and seek to make as few drops as possible. Broken eggs cannot be reused. Let &lt;math&gt;E(k, n)&lt;/math&gt; be the minimum number of egg drops that will always suffice.
:(a) Show that &lt;math&gt;E(1, n) = n&lt;/math&gt;.
:(b) Show that &lt;math&gt;E(k, n) = \Theta (n^{1/k})&lt;/math&gt;.
:(c) Find a recurrence for &lt;math&gt;E(k, n)&lt;/math&gt;. What is the running time of the dynamic program to find &lt;math&gt;E(k, n)&lt;/math&gt;?

===Graphing Problem===

:[[10.27]]. Consider a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. 
:Unfortunately, the city has bad neighborhoods, whose intersections we do not want to walk in. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is in a neighborhood to avoid.
:(a) Give an example of the contents of bad such that there is no path across the grid avoiding bad neighborhoods.
:(b) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find a path across the grid that avoids bad neighborhoods.
:(c) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find the shortest path across the grid that avoids bad neighborhoods. You may assume that all blocks are of equal length. For partial credit, give an &lt;math&gt;O(X^2Y^2)&lt;/math&gt; algorithm.
[[10.27|Solution]]


:10.28. Consider the same situation as the previous problem. We have a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is somewhere we want to avoid.
:If there were no bad neighborhoods to contend with, the shortest path across the grid would have length &lt;math&gt;(X - 1) + (Y - 1)&lt;/math&gt; blocks, and indeed there would be many such paths across the grid. Each path would consist of only rightward and downward moves.
:Give an algorithm that takes the array bad and returns the number of safe paths of length &lt;math&gt;X + Y - 2&lt;/math&gt;. For full credit, your algorithm must run in &lt;math&gt;O(XY)&lt;/math&gt;.


:[[10.29]]. You seek to create a stack out of &lt;math&gt;n&lt;/math&gt; boxes, where box &lt;math&gt;i&lt;/math&gt; has width &lt;math&gt;w_i&lt;/math&gt;, height &lt;math&gt;h_i&lt;/math&gt;, and depth &lt;math&gt;d_i&lt;/math&gt;. The boxes cannot be rotated, and can only be stacked on top of one another when each box in the stack is strictly larger than the box above it in width, height, and depth. Give an efficient algorithm to construct the tallest possible stack, where the height is the sum of the heights of each box in the stack.
[[10.29|Solution]]

===Design Problems===

:10.30. Consider the problem of storing &lt;math&gt;n&lt;/math&gt; books on shelves in a library. The order of the books is fixed by the cataloging system and so cannot be rearranged. Therefore, we can speak of a book &lt;math&gt;b_i&lt;/math&gt;, where &lt;math&gt;1 \leq i \leq n&lt;/math&gt;, that has a thickness &lt;math&gt;t_i&lt;/math&gt; and height &lt;math&gt;h_i&lt;/math&gt;. The length of each bookshelf at this library is &lt;math&gt;L&lt;/math&gt;.
:Suppose all the books have the same height &lt;math&gt;h&lt;/math&gt; (i.e., &lt;math&gt;h = h_i&lt;/math&gt; for all &lt;math&gt;i&lt;/math&gt;) and the shelves are all separated by a distance greater than &lt;math&gt;h&lt;/math&gt;, so any book fits on any shelf. The greedy algorithm would fill the first shelf with as many books as we can until we get the smallest &lt;math&gt;i&lt;/math&gt; such that &lt;math&gt;b_i&lt;/math&gt; does not fit, and then repeat with subsequent shelves. Show that the greedy algorithm always finds the book placement that uses the minimum number of shelves, and analyze its time complexity.


:[[10.31]]. This is a generalization of the previous problem. Now consider the case where the height of the books is not constant, but we have the freedom to adjust the height of each shelf to that of the tallest book on the shelf. Here the cost of a particular layout is the sum of the heights of the largest book on each shelf.
:#Give an example to show that the greedy algorithm of stuffing each shelf as full as possible does not always give the minimum overall height.
:#Give an algorithm for this problem, and analyze its time complexity. (Hint: use dynamic programming.)
[[10.31|Solution]]


:10.32. Consider a linear keyboard of lowercase letters and numbers, where the left-most 26 keys are the letters A–Z in order, followed by the digits 0–9 in order, followed by the 30 punctuation characters in a prescribed order, and ended on a blank. Assume you start with your left index finger on the “A” and your right index finger on the blank.
:Give a dynamic programming algorithm that finds the most efficient way to type a given text of length &lt;math&gt;n&lt;/math&gt;, in terms of minimizing total movement of the fingers involved. For the text &lt;math&gt;ABABABAB . . . ABAB&lt;/math&gt;, this would involve shifting both fingers all the way to the left side of the keyboard. Analyze the complexity of your algorithm as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;, the number of keys on the keyboard.


:[[10.33]]. You have come back from the future with an array &lt;math&gt;G&lt;/math&gt;, where &lt;math&gt;G[i]&lt;/math&gt; tells you the price of Google stock &lt;math&gt;i&lt;/math&gt; days from now, for &lt;math&gt;1 \leq i \leq n&lt;/math&gt;. You seek to use this information to maximize your profit, but are only permitted to complete at most one transaction (i.e. either buy one or sell one share of the stock) per day. Design an efficient algorithm to construct the buy–sell sequence to maximize your profit. Note that you cannot sell a share unless you currently own one.
[[10.33|Solution]]


:10.34. You are given a string of &lt;math&gt;n&lt;/math&gt; characters &lt;math&gt;S = s_1 . . . s_n&lt;/math&gt;, which you believe to be a compressed text document in which all spaces have been removed, like '''itwasthebestoftimes'''.
:(a) You seek to reconstruct the document using a dictionary, which is available in the form of a Boolean function &lt;math&gt;dict(w)&lt;/math&gt;, where &lt;math&gt;dict(w)&lt;/math&gt; is true iff string &lt;math&gt;w&lt;/math&gt; is a valid word in the language. Give an &lt;math&gt;O(n^2)&lt;/math&gt; algorithm to determine whether string &lt;math&gt;S&lt;/math&gt; can be reconstituted as a sequence of valid words, assuming calls to &lt;math&gt;dict(w &lt;/math&gt; take unit time.
:(b) Now assume you are given the dictionary as a set of &lt;math&gt;m&lt;/math&gt; words each of length at most l. Give an efficient algorithm to determine whether string &lt;math&gt;S&lt;/math&gt; can be reconstituted as a sequence of valid words, and its running time.


:[[10.35]]. Consider the following two-player game, where you seek to get the biggest score. You start with an n-digit integer &lt;math&gt;N&lt;/math&gt;. With each move, you get to take either the first digit or the last digit from what is left of &lt;math&gt;N&lt;/math&gt;, and add that to your score, with your opponent then doing the same thing to the now smaller number. You continue taking turns removing digits until none are left. Give an efficient algorithm that finds the best possible score that the first player can get for a given digit string &lt;math&gt;N&lt;/math&gt;, assuming the second player is as smart as can be.
[[10.35|Solution]]


:10.36. Given an array of &lt;math&gt;n&lt;/math&gt; real numbers, consider the problem of finding the maximum sum in any contiguous subarray of the input. For example, in the array
&lt;center&gt;&lt;math&gt;[31, -41, 59, 26, -53, 58, 97, -93, -23, 84]&lt;/math&gt;&lt;/center&gt;
:the maximum is achieved by summing the third through seventh elements, where 59 + 26 + (−53) + 58 + 97 = 187. When all numbers are positive, the entire array is the answer, while when all numbers are negative, the empty array maximizes the total at 0.
#Give a simple and clear &lt;math&gt; \Theta (n^2)&lt;/math&gt;-time algorithm to find the maximum contiguous subarray.
#Now give a &lt;math&gt;\Theta (n)&lt;/math&gt;-time dynamic programming algorithm for this problem. To get partial credit, you may instead give a correct &lt;math&gt;O(n log n)&lt;/math&gt; divide-and-conquer algorithm.


:[[10.37]]. Consider the problem of examining a string &lt;math&gt;x = x_1 x_2 \ldots x_n&lt;/math&gt; from an alphabet of &lt;math&gt;k&lt;/math&gt; symbols, and a multiplication table over this alphabet. Decide whether or not it is possible to parenthesize &lt;math&gt;x&lt;/math&gt; in such a way that the value of the resulting expression is &lt;math&gt;a&lt;/math&gt;, where &lt;math&gt;a&lt;/math&gt; belongs to the alphabet. The multiplication table is neither commutative or associative, so the order of multiplication matters.
&lt;center&gt;
&lt;math&gt;\begin{array}{c|ccc}
&amp;       a       &amp;       b       &amp;       c      \\
\hline
a       &amp;       a      &amp;       c      &amp;       c  \\
b       &amp;       a      &amp;       a      &amp;       b  \\
c       &amp;       c      &amp;       c      &amp;       c  \\
\end{array}&lt;/math&gt;
&lt;/center&gt;
:For example, consider the above multiplication table and the string &lt;math&gt;bbbba&lt;/math&gt;. Parenthesizing it &lt;math&gt;(b(bb))(ba)&lt;/math&gt; gives &lt;math&gt;a&lt;/math&gt;, but &lt;math&gt;((((bb)b)b)a)&lt;/math&gt; gives &lt;math&gt;c&lt;/math&gt;. 
:Give an algorithm, with time polynomial in &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;, to decide whether such a parenthesization exists for a given string, multiplication table, and goal element.
[[10.37|Solution]]


:10.38. Let α and β be constants. Assume that it costs α to go left in a binary search tree, and β to go right. Devise an algorithm that builds a tree with optimal expected query cost, given keys &lt;math&gt;k_1, . . . , k_n&lt;/math&gt; and the probabilities that each will be searched &lt;math&gt;p_1, . . . , p_n&lt;/math&gt;.

===Interview Problems===

:[[10.39]]. Given a set of coin denominations, find the minimum number of coins to make a certain amount of change.
[[10.39|Solution]]


:10.40. You are given an array of n numbers, each of which may be positive, negative, or zero. Give an efficient algorithm to identify the index positions &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; to obtain the maximum sum of the &lt;math&gt;i&lt;/math&gt;th through &lt;math&gt;j&lt;/math&gt;th numbers.


:[[10.41]]. Observe that when you cut a character out of a magazine, the character on the reverse side of the page is also removed. Give an algorithm to determine whether you can generate a given string by pasting cutouts from a given magazine. Assume that you are given a function that will identify the character and its position on the reverse side of the page for any given character position.
[[10.41|Solution]]


Back to [[Chapter List]]</text>
      <sha1>9abuw7ivvauizdk9jdnphanyndhh4yt</sha1>
    </revision>
    <revision>
      <id>456</id>
      <parentid>394</parentid>
      <timestamp>2020-10-01T18:10:29Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <minor/>
      <comment>Protected "[[Chapter 10]]" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="24860">=Dynamic Programming=

===Elementary Recurrences===

:[[10.1]]. Up to &lt;math&gt;k&lt;/math&gt; steps in a single bound! A child is running up a staircase with &lt;math&gt;n&lt;/math&gt; steps and can hop between 1 and &lt;math&gt;k&lt;/math&gt; steps at a time. Design an algorithm to count how many possible ways the child can run up the stairs, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. What is the running time of your algorithm?
[[10.1|Solution]]


:10.2. Imagine you are a professional thief who plans to rob houses along a street of &lt;math&gt;n&lt;/math&gt; homes. You know the loot at house &lt;math&gt;i&lt;/math&gt; is worth &lt;math&gt;m_i&lt;/math&gt;, for &lt;math&gt;1 \le i \le n&lt;/math&gt;, but you cannot rob neighboring houses because their connected security systems will automatically contact the police if two adjacent houses are broken into. Give an efficient algorithm to determine the maximum amount of money you can steal without alerting the police.


:[[10.3]]. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible mixes (1s,2s,3s) of scoring add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are four possible solutions: (5, 0, 0), (2, 0, 1), (1, 2, 0), and (0, 1, 1).
[[10.3|Solution]]


:10.4. Basketball games are a sequence of 2-point shots, 3-point shots, and 1-point free throws. Give an algorithm that computes how many possible scoring sequences add up to a given &lt;math&gt;n&lt;/math&gt;. For &lt;math&gt;n&lt;/math&gt; = 5 there are thirteen possible sequences, including 1-2-1-1, 3-2, and 1-1-1-1-1.


:[[10.5]]. Given an &lt;math&gt;s * t&lt;/math&gt; grid filled with non-negative numbers, find a path from top left to bottom right that minimizes the sum of all numbers along its path. You can only move either down or right at any point in time.
::(a) Give a solution based on Dijkstra’s algorithm. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
::(b) Give a solution based on dynamic programming. What is its time complexity as a function of &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;?
[[10.5|Solution]]

===Edit Distance===

:10.6. Typists often make transposition errors exchanging neighboring characters, such as typing “setve” for “steve.” This requires two substitutions to fix under the conventional definition of edit distance.
:Incorporate a swap operation into our edit distance function, so that such neighboring transposition errors can be fixed at the cost of one operation.


:[[10.7]]. Suppose you are given three strings of characters: &lt;math&gt;X&lt;/math&gt;, &lt;math&gt;Y&lt;/math&gt;, and &lt;math&gt;Z&lt;/math&gt;, where &lt;math&gt;|X| = n&lt;/math&gt;, &lt;math&gt;|Y| = m&lt;/math&gt;, and &lt;math&gt;|Z| = n + m&lt;/math&gt;. &lt;math&gt;Z&lt;/math&gt; is said to be a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; iff &lt;math&gt;Z&lt;/math&gt; can be formed by interleaving the characters from &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; in a way that maintains the left-to-right ordering of the characters from each string. 
:(a) Show that cchocohilaptes is a shuffle of chocolate and chips, but chocochilatspe is not.
:(b) Give an efficient dynamic programming algorithm that determines whether &lt;math&gt;Z&lt;/math&gt; is a shuffle of &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt;. (Hint: the values of the dynamic programming matrix you construct should be Boolean, not numeric.)
[[10.7|Solution]]


:10.8. The longest common substring (not subsequence) of two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; is the longest string that appears as a run of consecutive letters in both strings. For example, the longest common substring of photograph and tomography is ograph.
:(a) Let &lt;math&gt;n = |X|&lt;/math&gt; and &lt;math&gt;m = |Y|&lt;/math&gt;. Give a &lt;math&gt;\Theta (nm)&lt;/math&gt; dynamic programming algorithm for longest common substring based on the longest common subsequence/edit distance algorithm.
:(b) Give a simpler &lt;math&gt;\Theta (nm)&lt;/math&gt; algorithm that does not rely on dynamic programming.


:[[10.9]]. The ''longest common subsequence (LCS)'' of two sequences &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the longest sequence &lt;math&gt;L&lt;/math&gt; such that &lt;math&gt;L&lt;/math&gt; is a subsequence of both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;. The ''shortest common supersequence (SCS)'' of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; is the smallest sequence &lt;math&gt;L&lt;/math&gt; such that both &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; are a subsequence of &lt;math&gt;L&lt;/math&gt;.
:(a) Give efficient algorithms to find the LCS and SCS of two given sequences.
:(b) Let &lt;math&gt;d(T, P)&lt;/math&gt; be the minimum edit distance between &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt; when no substitutions are allowed (i.e., the only changes are character insertion and deletion). Prove that &lt;math&gt;d(T, P) = |SCS(T, P)| - |LCS(T, P)|&lt;/math&gt; where &lt;math&gt;|SCS(T, P)| (|LCS(T, P)|)&lt;/math&gt; is the size of the shortest SCS (longest LCS) of &lt;math&gt;T&lt;/math&gt; and &lt;math&gt;P&lt;/math&gt;.
[[10.9|Solution]]


:10.10. Suppose you are given &lt;math&gt;n&lt;/math&gt; poker chips stacked in two stacks, where the edges of all chips can be seen. Each chip is one of three colors. A turn consists of choosing a color and removing all chips of that color from the tops of the stacks. The goal is to minimize the number of turns until the chips are gone. 
:For example, consider the stacks &lt;math&gt;(RRGG, GBBB)&lt;/math&gt;. Playing red, green, and then blue suffices to clear the stacks in three moves. Give an &lt;math&gt;O(n^2)&lt;/math&gt; dynamic programming algorithm to find the best strategy for a given pair of chip piles.

===Greedy Algorithms===

:[[10.11]]. Let &lt;math&gt;P_1, P_2, . . . , P_n&lt;/math&gt; be &lt;math&gt;n&lt;/math&gt; programs to be stored on a disk with capacity &lt;math&gt;D&lt;/math&gt; megabytes. Program &lt;math&gt;P_i&lt;/math&gt; requires &lt;math&gt;s_i&lt;/math&gt; megabytes of storage. We cannot store them all because &lt;math&gt;D &lt; \sum_{i=1}^n s_i &lt;/math&gt;
:(a) Does a greedy algorithm that selects programs in order of non-decreasing &lt;math&gt;s_i&lt;/math&gt; maximize the number of programs held on the disk? Prove or give a counter-example.
:(b) Does a greedy algorithm that selects programs in order of non-increasing &lt;math&gt;s_i&lt;/math&gt; use as much of the capacity of the disk as possible? Prove or give a counter-example.
[[10.11|Solution]]


:10.12. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We seek an algorithm to make change of &lt;math&gt;n&lt;/math&gt; units using the minimum number of this country’s coins.
:(a) The greedy algorithm repeatedly selects the biggest coin no bigger than the amount to be changed and repeats until it is zero. Show that the greedy algorithm does not always use the minimum number of coins in a country whose denominations are {1, 6, 10}.
:(b) Give an efficient algorithm that correctly determines the minimum number of coins needed to make change of &lt;math&gt;n&lt;/math&gt; units using denominations &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt;. Analyze its running time.


:[[10.13]]. Coins in the United States are minted with denominations of 1, 5, 10, 25, and 50 cents. Now consider a country whose coins are minted with denominations of &lt;math&gt;{d_1, . . . , d_k}&lt;/math&gt; units. We want to count how many distinct ways &lt;math&gt;C(n)&lt;/math&gt; there are to make change of &lt;math&gt;n&lt;/math&gt; units. For example, in a country whose denominations are {1, 6, 10}, &lt;math&gt;C(5) = 1&lt;/math&gt;, &lt;math&gt;C(6)&lt;/math&gt; to &lt;math&gt;C(9) = 2&lt;/math&gt;, &lt;math&gt;C(10) = 3&lt;/math&gt;, and &lt;math&gt;C(12) = 4&lt;/math&gt;.
:(a) How many ways are there to make change of 20 units from {1, 6, 10}?
:(b) Give an efficient algorithm to compute &lt;math&gt;C(n)&lt;/math&gt;, and analyze its complexity. (Hint: think in terms of computing &lt;math&gt;C(n, d)&lt;/math&gt;, the number of ways to make change of &lt;math&gt;n&lt;/math&gt; units with highest denomination &lt;math&gt;d&lt;/math&gt;. Be careful to avoid overcounting.)
[[10.13|Solution]]


:10.14. In the single-processor scheduling problem, we are given a set of &lt;math&gt;n&lt;/math&gt; jobs &lt;math&gt;J&lt;/math&gt;. Each job &lt;math&gt;i&lt;/math&gt; has a processing time &lt;math&gt;t_i&lt;/math&gt;, and a deadline &lt;math&gt;d_i&lt;/math&gt;. A feasible schedule is a permutation of the jobs such that when the jobs are performed in that order, every job is finished before its deadline. The greedy algorithm for single-processor scheduling selects the job with the earliest deadline first.
:Show that if a feasible schedule exists, then the schedule produced by this greedy algorithm is feasible.

===Number Problems===

:[[10.15]]. You are given a rod of length &lt;math&gt;n&lt;/math&gt; inches and a table of prices obtainable for rod-pieces of size &lt;math&gt;n&lt;/math&gt; or smaller. Give an efficient algorithm to find the maximum value obtainable by cutting up the rod and selling the pieces. For example, if &lt;math&gt;n=8&lt;/math&gt; and the values of different pieces are:
&lt;center&gt;&lt;math&gt;	
\begin{array}{|c|c|c|c|c|c|c|c||c|} length &amp; 1 &amp; 2 &amp; 3 &amp; 4 &amp; 5 &amp; 6 &amp; 7 &amp; 8\\
\hline
price&amp;1&amp;5&amp;8&amp;9&amp;10&amp;17&amp;17&amp;20\\
\end{array}&lt;/math&gt;
&lt;/center&gt;
:then the maximum obtainable value is 22, by cutting into pieces of lengths 2 and 6.
[[10.15|Solution]]


:10.16. Your boss has written an arithmetic expression of n terms to compute your annual bonus, but permits you to parenthesize it however you wish. Give an efficient algorithm to design the parenthesization to maximize the value. For the expression:
&lt;center&gt;&lt;math&gt;6 + 2 * 0 - 4&lt;/math&gt;&lt;/center&gt;
:there exist parenthesizations with values ranging from −32 to 2.


:[[10.17]]. Given a positive integer &lt;math&gt;n&lt;/math&gt;, find an efficient algorithm to compute the smallest number of perfect squares (e.g. 1, 4, 9, 16, . . .) that sum to &lt;math&gt;n&lt;/math&gt;. What is the running time of your algorithm?
[[10.17|Solution]]


:10.18. Given an array &lt;math&gt;A&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find an efficient algorithm to compute the largest sum of a continuous run. For &lt;math&gt;A = [-3, 2, 7, -3, 4, -2, 0, 1]&lt;/math&gt;, the largest such sum is 10, from the second through fifth positions.


:[[10.19]]. Two drivers have to divide up &lt;math&gt;m&lt;/math&gt; suitcases between them, where the weight of the &lt;math&gt;ith&lt;/math&gt; suitcase is &lt;math&gt;w_i&lt;/math&gt;. Give an efficient algorithm to divide up the loads so the two drivers carry equal weight, if possible.
[[10.19|Solution]]


:10.20. The ''knapsack problem'' is as follows: given a set of integers &lt;math&gt;S = {s_1, s_2, . . . , s_n}&lt;/math&gt;, and a given target number &lt;math&gt;T&lt;/math&gt;, find a subset of &lt;math&gt;S&lt;/math&gt; that adds up exactly to &lt;math&gt;T&lt;/math&gt;. For example, within &lt;math&gt;S = {1, 2, 5, 9, 10}&lt;/math&gt; there is a subset that adds up to &lt;math&gt;T = 22&lt;/math&gt; but not &lt;math&gt;T = 23&lt;/math&gt;.
:Give a dynamic programming algorithm for knapsack that runs in &lt;math&gt;O(nT)&lt;/math&gt; time.


:[[10.21]]. The integer partition takes a set of positive integers &lt;math&gt;S = {s_1, . . . , s_n}&lt;/math&gt; and seeks a subset &lt;math&gt;I \subset S&lt;/math&gt; such that
&lt;center&gt;&lt;math&gt; \sum_{i \in I} s_i = \sum_{i \notin I} s_i&lt;/math&gt;&lt;/center&gt;
:Let &lt;math&gt; \sum_{i \in S} s_i = M &lt;/math&gt;. Give an &lt;math&gt;O(nM)&lt;/math&gt; dynamic programming algorithm to solve the integer partition problem.
[[10.21|Solution]]


:10.22. Assume that there are n numbers (some possibly negative) on a circle, and we wish to find the maximum contiguous sum along an arc of the circle. Give an efficient algorithm for solving this problem.


:[[10.23]]. A certain string processing language allows the programmer to break a string into two pieces. It costs &lt;math&gt;n&lt;/math&gt; units of time to break a string of &lt;math&gt;n&lt;/math&gt; characters into two pieces, since this involves copying the old string. A programmer wants to break a string into many pieces, and the order in which the breaks are made can affect the total amount of time used. For example, suppose we wish to break a 20-character string after characters 3, 8, and 10. If the breaks are made in left-to-right order, then the first break costs 20 units of time, the second break costs 17 units of time, and the third break costs 12 units of time, for a total of 49 units. If the breaks are made in right-to-left order, the first break costs 20 units of time, the second break costs 10 units of time, and the third break costs 8 units of time, for a total of only 38 units.
:Give a dynamic programming algorithm that takes a list of character positions after which to break and determines the cheapest break cost in &lt;math&gt;O(n^3)&lt;/math&gt; time.
[[10.23|Solution]]


:10.24. Consider the following data compression technique. We have a table of &lt;math&gt;m&lt;/math&gt; text strings, each at most &lt;math&gt;k&lt;/math&gt; in length. We want to encode a data string &lt;math&gt;D&lt;/math&gt; of length &lt;math&gt;n&lt;/math&gt; using as few text strings as possible. For example, if our table contains &lt;math&gt;(a,ba,abab,b)&lt;/math&gt; and the data string is &lt;math&gt;bababbaababa&lt;/math&gt;, the best way to encode it is &lt;math&gt;(b,abab,ba,abab,a)-a&lt;/math&gt; total of five code words. Give an &lt;math&gt;O(nmk)&lt;/math&gt; algorithm to find the length of the best encoding. You may assume that every string has at least one encoding in terms of the table.


:[[10.25]]. The traditional world chess championship is a match of 24 games. The current champion retains the title in case the match is a tie. Each game ends in a win, loss, or draw (tie) where wins count as 1, losses as 0, and draws as &lt;math&gt;1/2&lt;/math&gt;. The players take turns playing white and black. White plays first and so has an advantage. The champion plays white in the first game. The champ has probabilities &lt;math&gt;w_w&lt;/math&gt;, &lt;math&gt;w_d&lt;/math&gt;, and &lt;math&gt;w_l&lt;/math&gt; of winning, drawing, and losing playing white, and has probabilities &lt;math&gt;b_w&lt;/math&gt;, &lt;math&gt;b_d&lt;/math&gt;, and &lt;math&gt;b_l&lt;/math&gt; of winning, drawing, and losing playing black.
:(a) Write a recurrence for the probability that the champion retains the title. Assume that there are &lt;math&gt;g&lt;/math&gt; games left to play in the match and that the champion needs to get &lt;math&gt;i&lt;/math&gt; points (which may be a multiple of &lt;math&gt;1/2&lt;/math&gt;).
:(b) Based on your recurrence, give a dynamic programming algorithm to calculate the champion’s probability of retaining the title.
:(c) Analyze its running time for an &lt;math&gt;n&lt;/math&gt; game match.
[[10.25|Solution]]


:10.26. Eggs break when dropped from great enough height. Specifically, there must be a floor &lt;math&gt;f&lt;/math&gt; in any sufficiently tall building such that an egg dropped from the &lt;math&gt;f&lt;/math&gt;th floor breaks, but one dropped from the &lt;math&gt;(f - 1)&lt;/math&gt;st floor will not. If the egg always breaks, then &lt;math&gt;f = 1&lt;/math&gt;. If the egg never breaks, then &lt;math&gt;f = n + 1&lt;/math&gt;. 
:You seek to find the critical floor &lt;math&gt;f&lt;/math&gt; using an &lt;math&gt;n-floor&lt;/math&gt; building. The only operation you can perform is to drop an egg off some floor and see what happens. You start out with &lt;math&gt;k&lt;/math&gt; eggs, and seek to make as few drops as possible. Broken eggs cannot be reused. Let &lt;math&gt;E(k, n)&lt;/math&gt; be the minimum number of egg drops that will always suffice.
:(a) Show that &lt;math&gt;E(1, n) = n&lt;/math&gt;.
:(b) Show that &lt;math&gt;E(k, n) = \Theta (n^{1/k})&lt;/math&gt;.
:(c) Find a recurrence for &lt;math&gt;E(k, n)&lt;/math&gt;. What is the running time of the dynamic program to find &lt;math&gt;E(k, n)&lt;/math&gt;?

===Graphing Problem===

:[[10.27]]. Consider a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. 
:Unfortunately, the city has bad neighborhoods, whose intersections we do not want to walk in. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is in a neighborhood to avoid.
:(a) Give an example of the contents of bad such that there is no path across the grid avoiding bad neighborhoods.
:(b) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find a path across the grid that avoids bad neighborhoods.
:(c) Give an &lt;math&gt;O(XY)&lt;/math&gt; algorithm to find the shortest path across the grid that avoids bad neighborhoods. You may assume that all blocks are of equal length. For partial credit, give an &lt;math&gt;O(X^2Y^2)&lt;/math&gt; algorithm.
[[10.27|Solution]]


:10.28. Consider the same situation as the previous problem. We have a city whose streets are defined by an &lt;math&gt;X * Y&lt;/math&gt; grid. We are interested in walking from the upper left-hand corner of the grid to the lower right-hand corner. We are given an &lt;math&gt;X * Y&lt;/math&gt; matrix bad, where &lt;math&gt;bad[i,j] =&lt;/math&gt; “yes” iff the intersection between streets &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; is somewhere we want to avoid.
:If there were no bad neighborhoods to contend with, the shortest path across the grid would have length &lt;math&gt;(X - 1) + (Y - 1)&lt;/math&gt; blocks, and indeed there would be many such paths across the grid. Each path would consist of only rightward and downward moves.
:Give an algorithm that takes the array bad and returns the number of safe paths of length &lt;math&gt;X + Y - 2&lt;/math&gt;. For full credit, your algorithm must run in &lt;math&gt;O(XY)&lt;/math&gt;.


:[[10.29]]. You seek to create a stack out of &lt;math&gt;n&lt;/math&gt; boxes, where box &lt;math&gt;i&lt;/math&gt; has width &lt;math&gt;w_i&lt;/math&gt;, height &lt;math&gt;h_i&lt;/math&gt;, and depth &lt;math&gt;d_i&lt;/math&gt;. The boxes cannot be rotated, and can only be stacked on top of one another when each box in the stack is strictly larger than the box above it in width, height, and depth. Give an efficient algorithm to construct the tallest possible stack, where the height is the sum of the heights of each box in the stack.
[[10.29|Solution]]

===Design Problems===

:10.30. Consider the problem of storing &lt;math&gt;n&lt;/math&gt; books on shelves in a library. The order of the books is fixed by the cataloging system and so cannot be rearranged. Therefore, we can speak of a book &lt;math&gt;b_i&lt;/math&gt;, where &lt;math&gt;1 \leq i \leq n&lt;/math&gt;, that has a thickness &lt;math&gt;t_i&lt;/math&gt; and height &lt;math&gt;h_i&lt;/math&gt;. The length of each bookshelf at this library is &lt;math&gt;L&lt;/math&gt;.
:Suppose all the books have the same height &lt;math&gt;h&lt;/math&gt; (i.e., &lt;math&gt;h = h_i&lt;/math&gt; for all &lt;math&gt;i&lt;/math&gt;) and the shelves are all separated by a distance greater than &lt;math&gt;h&lt;/math&gt;, so any book fits on any shelf. The greedy algorithm would fill the first shelf with as many books as we can until we get the smallest &lt;math&gt;i&lt;/math&gt; such that &lt;math&gt;b_i&lt;/math&gt; does not fit, and then repeat with subsequent shelves. Show that the greedy algorithm always finds the book placement that uses the minimum number of shelves, and analyze its time complexity.


:[[10.31]]. This is a generalization of the previous problem. Now consider the case where the height of the books is not constant, but we have the freedom to adjust the height of each shelf to that of the tallest book on the shelf. Here the cost of a particular layout is the sum of the heights of the largest book on each shelf.
:#Give an example to show that the greedy algorithm of stuffing each shelf as full as possible does not always give the minimum overall height.
:#Give an algorithm for this problem, and analyze its time complexity. (Hint: use dynamic programming.)
[[10.31|Solution]]


:10.32. Consider a linear keyboard of lowercase letters and numbers, where the left-most 26 keys are the letters A–Z in order, followed by the digits 0–9 in order, followed by the 30 punctuation characters in a prescribed order, and ended on a blank. Assume you start with your left index finger on the “A” and your right index finger on the blank.
:Give a dynamic programming algorithm that finds the most efficient way to type a given text of length &lt;math&gt;n&lt;/math&gt;, in terms of minimizing total movement of the fingers involved. For the text &lt;math&gt;ABABABAB . . . ABAB&lt;/math&gt;, this would involve shifting both fingers all the way to the left side of the keyboard. Analyze the complexity of your algorithm as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;, the number of keys on the keyboard.


:[[10.33]]. You have come back from the future with an array &lt;math&gt;G&lt;/math&gt;, where &lt;math&gt;G[i]&lt;/math&gt; tells you the price of Google stock &lt;math&gt;i&lt;/math&gt; days from now, for &lt;math&gt;1 \leq i \leq n&lt;/math&gt;. You seek to use this information to maximize your profit, but are only permitted to complete at most one transaction (i.e. either buy one or sell one share of the stock) per day. Design an efficient algorithm to construct the buy–sell sequence to maximize your profit. Note that you cannot sell a share unless you currently own one.
[[10.33|Solution]]


:10.34. You are given a string of &lt;math&gt;n&lt;/math&gt; characters &lt;math&gt;S = s_1 . . . s_n&lt;/math&gt;, which you believe to be a compressed text document in which all spaces have been removed, like '''itwasthebestoftimes'''.
:(a) You seek to reconstruct the document using a dictionary, which is available in the form of a Boolean function &lt;math&gt;dict(w)&lt;/math&gt;, where &lt;math&gt;dict(w)&lt;/math&gt; is true iff string &lt;math&gt;w&lt;/math&gt; is a valid word in the language. Give an &lt;math&gt;O(n^2)&lt;/math&gt; algorithm to determine whether string &lt;math&gt;S&lt;/math&gt; can be reconstituted as a sequence of valid words, assuming calls to &lt;math&gt;dict(w &lt;/math&gt; take unit time.
:(b) Now assume you are given the dictionary as a set of &lt;math&gt;m&lt;/math&gt; words each of length at most l. Give an efficient algorithm to determine whether string &lt;math&gt;S&lt;/math&gt; can be reconstituted as a sequence of valid words, and its running time.


:[[10.35]]. Consider the following two-player game, where you seek to get the biggest score. You start with an n-digit integer &lt;math&gt;N&lt;/math&gt;. With each move, you get to take either the first digit or the last digit from what is left of &lt;math&gt;N&lt;/math&gt;, and add that to your score, with your opponent then doing the same thing to the now smaller number. You continue taking turns removing digits until none are left. Give an efficient algorithm that finds the best possible score that the first player can get for a given digit string &lt;math&gt;N&lt;/math&gt;, assuming the second player is as smart as can be.
[[10.35|Solution]]


:10.36. Given an array of &lt;math&gt;n&lt;/math&gt; real numbers, consider the problem of finding the maximum sum in any contiguous subarray of the input. For example, in the array
&lt;center&gt;&lt;math&gt;[31, -41, 59, 26, -53, 58, 97, -93, -23, 84]&lt;/math&gt;&lt;/center&gt;
:the maximum is achieved by summing the third through seventh elements, where 59 + 26 + (−53) + 58 + 97 = 187. When all numbers are positive, the entire array is the answer, while when all numbers are negative, the empty array maximizes the total at 0.
#Give a simple and clear &lt;math&gt; \Theta (n^2)&lt;/math&gt;-time algorithm to find the maximum contiguous subarray.
#Now give a &lt;math&gt;\Theta (n)&lt;/math&gt;-time dynamic programming algorithm for this problem. To get partial credit, you may instead give a correct &lt;math&gt;O(n log n)&lt;/math&gt; divide-and-conquer algorithm.


:[[10.37]]. Consider the problem of examining a string &lt;math&gt;x = x_1 x_2 \ldots x_n&lt;/math&gt; from an alphabet of &lt;math&gt;k&lt;/math&gt; symbols, and a multiplication table over this alphabet. Decide whether or not it is possible to parenthesize &lt;math&gt;x&lt;/math&gt; in such a way that the value of the resulting expression is &lt;math&gt;a&lt;/math&gt;, where &lt;math&gt;a&lt;/math&gt; belongs to the alphabet. The multiplication table is neither commutative or associative, so the order of multiplication matters.
&lt;center&gt;
&lt;math&gt;\begin{array}{c|ccc}
&amp;       a       &amp;       b       &amp;       c      \\
\hline
a       &amp;       a      &amp;       c      &amp;       c  \\
b       &amp;       a      &amp;       a      &amp;       b  \\
c       &amp;       c      &amp;       c      &amp;       c  \\
\end{array}&lt;/math&gt;
&lt;/center&gt;
:For example, consider the above multiplication table and the string &lt;math&gt;bbbba&lt;/math&gt;. Parenthesizing it &lt;math&gt;(b(bb))(ba)&lt;/math&gt; gives &lt;math&gt;a&lt;/math&gt;, but &lt;math&gt;((((bb)b)b)a)&lt;/math&gt; gives &lt;math&gt;c&lt;/math&gt;. 
:Give an algorithm, with time polynomial in &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;, to decide whether such a parenthesization exists for a given string, multiplication table, and goal element.
[[10.37|Solution]]


:10.38. Let α and β be constants. Assume that it costs α to go left in a binary search tree, and β to go right. Devise an algorithm that builds a tree with optimal expected query cost, given keys &lt;math&gt;k_1, . . . , k_n&lt;/math&gt; and the probabilities that each will be searched &lt;math&gt;p_1, . . . , p_n&lt;/math&gt;.

===Interview Problems===

:[[10.39]]. Given a set of coin denominations, find the minimum number of coins to make a certain amount of change.
[[10.39|Solution]]


:10.40. You are given an array of n numbers, each of which may be positive, negative, or zero. Give an efficient algorithm to identify the index positions &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; to obtain the maximum sum of the &lt;math&gt;i&lt;/math&gt;th through &lt;math&gt;j&lt;/math&gt;th numbers.


:[[10.41]]. Observe that when you cut a character out of a magazine, the character on the reverse side of the page is also removed. Give an algorithm to determine whether you can generate a given string by pasting cutouts from a given magazine. Assume that you are given a function that will identify the character and its position on the reverse side of the page for any given character position.
[[10.41|Solution]]


Back to [[Chapter List]]</text>
      <sha1>9abuw7ivvauizdk9jdnphanyndhh4yt</sha1>
    </revision>
  </page>
  <page>
    <title>Chapter 11</title>
    <ns>0</ns>
    <id>14</id>
    <revision>
      <id>23</id>
      <timestamp>2020-08-23T19:36:02Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Problems   Back to [[Chapter List]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="35">Problems


Back to [[Chapter List]]</text>
      <sha1>95722ndl4ewzic1ak6z8g4auy0tqhc6</sha1>
    </revision>
    <revision>
      <id>121</id>
      <parentid>23</parentid>
      <timestamp>2020-09-07T19:45:02Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="550">=NP-Completeness=

===Transformations and Satisfiability===

:[[11.1]]


:11.2


:[[11.3]]


:11.4


:[[11.5]]


:11.6


:[[11.7]]


:11.8


:[[11.9]]


===Basic Reductions===

:11.10


:[[11.11]]


:11.12


:[[11.13]]


:11.14


:[[11.15]]


:11.16


:[[11.17]]


:11.18


:[[11.19]]


:11.20


:[[11.21]]


===Creatvie Reductions===

:11.22


:[[11.23]]


:11.24


:[[11.25]]


:11.26


:[[11.27]]


:11.28


:[[11.29]]


:11.30


===Algorithms for Special Cases===

:[[11.31]]


:11.32


:[[11.33]]


:11.34


:[[11.35]]


Back to [[Chapter List]]</text>
      <sha1>8m51c74p6g5p2jvlrirh3dy44t41cmb</sha1>
    </revision>
    <revision>
      <id>180</id>
      <parentid>121</parentid>
      <timestamp>2020-09-10T21:32:23Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Transformations and Satisfiability */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="2588">=NP-Completeness=

===Transformations and Satisfiability===

:[[11.1]]. Give the 3-SAT formula that results from applying the reduction of SAT to 3-SAT for the formula: 
:::&lt;math&gt; (x\or y \or \overline z \or w \or u \or \overline v) \and (\overline x \or \overline 
y \or z \or \overline w \or u \or v) \and (x \or \overline y \or \overline z \or w \or u \or \overline v)\and (x \or \overline y) &lt;/math&gt;
[[11.1|Solution]]


:11.2. Draw the graph that results from the reduction of 3-SAT to vertex cover for the expression 
:::&lt;math&gt;(x \or \overline y \or z) \and (\overline x \or y \or \overline z) \and(\overline x \or y \or z) \and (x \or \overline y \or \overline x) &lt;/math&gt;


:[[11.3]]. Prove that 4-SAT is NP-hard.
[[11.3|Solution]]


:11.4. ''Stingy'' SAT is the following problem: given a set of clauses (each a disjunction of literals) and an integer &lt;math&gt;k&lt;/math&gt;, find a satisfying assignment in which at most &lt;math&gt;k&lt;/math&gt; variables are true, if such an assignment exists. Prove that stingy SAT is NP-hard.


:[[11.5]]. The ''Double SAT'' problem asks whether a given satisfiability problem has '''at least two different satisfying assignments'''. For example, the problem &lt;math&gt;{{v1, v2}, {v_1, v_2}, {v_1, v_2}}&lt;/math&gt; is satisfiable, but has only one solution &lt;math&gt;(v_1 =F, v_2 = T)&lt;/math&gt;. In contrast, &lt;math&gt;{{v_1, v_2}, {v_1, v_2}}&lt;/math&gt; has exactly two solutions. Show that Double-SAT is NP-hard.
[[11.5|Solution]]


:11.6. Suppose we are given a subroutine that can solve the traveling salesman decision problem on page 357 in (say) linear time. Give an efficient algorithm to find the actual TSP tour by making a polynomial number of calls to this subroutine.


:[[11.7]]. Implement a SAT to 3-SAT reduction that translates satisfiability instances into equivalent 3-SAT instances.
[[11.7|Solution]]


:11.8. Design and implement a backtracking algorithm to test whether a set of clause sets is satisfiable. What criteria can you use to prune this search?


:[[11.9]]. Implement the vertex cover to satisfiability reduction, and run the resulting clauses through a satisfiability solver code. Does this seem like a practical way to compute things?
[[11.9|Solution]]

===Basic Reductions===

:11.10


:[[11.11]]


:11.12


:[[11.13]]


:11.14


:[[11.15]]


:11.16


:[[11.17]]


:11.18


:[[11.19]]


:11.20


:[[11.21]]


===Creatvie Reductions===

:11.22


:[[11.23]]


:11.24


:[[11.25]]


:11.26


:[[11.27]]


:11.28


:[[11.29]]


:11.30


===Algorithms for Special Cases===

:[[11.31]]


:11.32


:[[11.33]]


:11.34


:[[11.35]]


Back to [[Chapter List]]</text>
      <sha1>prlx9ugm03fm5il4vd6v30z2azvm6ok</sha1>
    </revision>
    <revision>
      <id>187</id>
      <parentid>180</parentid>
      <timestamp>2020-09-10T21:41:26Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Basic Reductions */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="4893">=NP-Completeness=

===Transformations and Satisfiability===

:[[11.1]]. Give the 3-SAT formula that results from applying the reduction of SAT to 3-SAT for the formula: 
:::&lt;math&gt; (x\or y \or \overline z \or w \or u \or \overline v) \and (\overline x \or \overline 
y \or z \or \overline w \or u \or v) \and (x \or \overline y \or \overline z \or w \or u \or \overline v)\and (x \or \overline y) &lt;/math&gt;
[[11.1|Solution]]


:11.2. Draw the graph that results from the reduction of 3-SAT to vertex cover for the expression 
:::&lt;math&gt;(x \or \overline y \or z) \and (\overline x \or y \or \overline z) \and(\overline x \or y \or z) \and (x \or \overline y \or \overline x) &lt;/math&gt;


:[[11.3]]. Prove that 4-SAT is NP-hard.
[[11.3|Solution]]


:11.4. ''Stingy'' SAT is the following problem: given a set of clauses (each a disjunction of literals) and an integer &lt;math&gt;k&lt;/math&gt;, find a satisfying assignment in which at most &lt;math&gt;k&lt;/math&gt; variables are true, if such an assignment exists. Prove that stingy SAT is NP-hard.


:[[11.5]]. The ''Double SAT'' problem asks whether a given satisfiability problem has '''at least two different satisfying assignments'''. For example, the problem &lt;math&gt;{{v1, v2}, {v_1, v_2}, {v_1, v_2}}&lt;/math&gt; is satisfiable, but has only one solution &lt;math&gt;(v_1 =F, v_2 = T)&lt;/math&gt;. In contrast, &lt;math&gt;{{v_1, v_2}, {v_1, v_2}}&lt;/math&gt; has exactly two solutions. Show that Double-SAT is NP-hard.
[[11.5|Solution]]


:11.6. Suppose we are given a subroutine that can solve the traveling salesman decision problem on page 357 in (say) linear time. Give an efficient algorithm to find the actual TSP tour by making a polynomial number of calls to this subroutine.


:[[11.7]]. Implement a SAT to 3-SAT reduction that translates satisfiability instances into equivalent 3-SAT instances.
[[11.7|Solution]]


:11.8. Design and implement a backtracking algorithm to test whether a set of clause sets is satisfiable. What criteria can you use to prune this search?


:[[11.9]]. Implement the vertex cover to satisfiability reduction, and run the resulting clauses through a satisfiability solver code. Does this seem like a practical way to compute things?
[[11.9|Solution]]

===Basic Reductions===

:11.10. An instance of the ''set cover'' problem consists of a set &lt;math&gt;X&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; elements, a family &lt;math&gt;F&lt;/math&gt; of subsets of &lt;math&gt;X&lt;/math&gt;, and an integer &lt;math&gt;k&lt;/math&gt;. The question is, does there exist &lt;math&gt;k&lt;/math&gt; subsets from &lt;math&gt;F&lt;/math&gt; whose union is &lt;math&gt;X&lt;/math&gt;? For example, if &lt;math&gt;X = \{1,2,3,4\}&lt;/math&gt; and &lt;math&gt;F = \{ \{1,2\}, \{2,3\}, \{4\}, \{2,4\} \}&lt;/math&gt;, there does not exist a solution for &lt;math&gt;k=2&lt;/math&gt;, but there does for &lt;math&gt;k=3&lt;/math&gt; (for example, &lt;math&gt; \{1,2\}, \{2,3\}, \{4\}&lt;/math&gt;). Prove that set cover is NP-complete with a reduction from vertex cover.


:[[11.11]]. The ''baseball card collector problem'' is as follows. Given packets &lt;math&gt;P_1, \ldots, P_m&lt;/math&gt;, each of which contains a subset of this year's baseball cards, is it possible to collect all the year's cards by buying &lt;math&gt;\leq k&lt;/math&gt; packets? For example, if the players are &lt;math&gt; \{Aaron, Mays, Ruth, Steven \} &lt;/math&gt; and the packets are
:::&lt;math&gt; \{ \{Aaron,Mays\}, \{Mays,Ruth\}, \{Steven\}, \{Mays,Steven\} \}, &lt;/math&gt; 
:there does not exist a solution for &lt;math&gt;k=2&lt;/math&gt;, but there does for &lt;math&gt;k=3&lt;/math&gt;, such as 
:::&lt;math&gt; \{Aaron,Mays\}, \{Mays,Ruth\}, \{Steven\} &lt;/math&gt; 
:Prove that the baseball card collector problem is NP hard using a reduction from vertex cover.


:11.12. The ''low-degree spanning tree problem'' is as follows. Given a graph &lt;math&gt;G&lt;/math&gt; and an integer &lt;math&gt;k&lt;/math&gt;, does &lt;math&gt;G&lt;/math&gt; contain a spanning tree such that all vertices in the tree have degree ''at most'' &lt;math&gt;k&lt;/math&gt; (obviously, only tree edges count towards the degree)? For example, in the following graph, there is no spanning tree such that all vertices have a degree less than three.
\fixedfigsize{pictures/lowdegree.png}{1.0in}
#Prove that the low-degree spanning tree problem is NP-hard with a reduction from Hamiltonian ''path''. 
#Now consider the ''high-degree spanning tree problem'', which is as follows. Given a graph &lt;math&gt;G&lt;/math&gt; and an integer &lt;math&gt;k&lt;/math&gt;, does &lt;math&gt;G&lt;/math&gt; contain a spanning tree whose highest degree vertex is ''at least'' &lt;math&gt;k&lt;/math&gt;? In the previous example, there exists a spanning tree with a highest degree of 8. Give an efficient algorithm to solve the high-degree spanning tree problem, and an analysis of its time complexity.


:[[11.13]]


:11.14


:[[11.15]]


:11.16


:[[11.17]]


:11.18


:[[11.19]]


:11.20


:[[11.21]]

===Creatvie Reductions===

:11.22


:[[11.23]]


:11.24


:[[11.25]]


:11.26


:[[11.27]]


:11.28


:[[11.29]]


:11.30


===Algorithms for Special Cases===

:[[11.31]]


:11.32


:[[11.33]]


:11.34


:[[11.35]]


Back to [[Chapter List]]</text>
      <sha1>b4zjcfl43n5ccoweycxfxmi43xqc1fo</sha1>
    </revision>
    <revision>
      <id>189</id>
      <parentid>187</parentid>
      <timestamp>2020-09-11T18:55:17Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Basic Reductions */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="8194">=NP-Completeness=

===Transformations and Satisfiability===

:[[11.1]]. Give the 3-SAT formula that results from applying the reduction of SAT to 3-SAT for the formula: 
:::&lt;math&gt; (x\or y \or \overline z \or w \or u \or \overline v) \and (\overline x \or \overline 
y \or z \or \overline w \or u \or v) \and (x \or \overline y \or \overline z \or w \or u \or \overline v)\and (x \or \overline y) &lt;/math&gt;
[[11.1|Solution]]


:11.2. Draw the graph that results from the reduction of 3-SAT to vertex cover for the expression 
:::&lt;math&gt;(x \or \overline y \or z) \and (\overline x \or y \or \overline z) \and(\overline x \or y \or z) \and (x \or \overline y \or \overline x) &lt;/math&gt;


:[[11.3]]. Prove that 4-SAT is NP-hard.
[[11.3|Solution]]


:11.4. ''Stingy'' SAT is the following problem: given a set of clauses (each a disjunction of literals) and an integer &lt;math&gt;k&lt;/math&gt;, find a satisfying assignment in which at most &lt;math&gt;k&lt;/math&gt; variables are true, if such an assignment exists. Prove that stingy SAT is NP-hard.


:[[11.5]]. The ''Double SAT'' problem asks whether a given satisfiability problem has '''at least two different satisfying assignments'''. For example, the problem &lt;math&gt;{{v1, v2}, {v_1, v_2}, {v_1, v_2}}&lt;/math&gt; is satisfiable, but has only one solution &lt;math&gt;(v_1 =F, v_2 = T)&lt;/math&gt;. In contrast, &lt;math&gt;{{v_1, v_2}, {v_1, v_2}}&lt;/math&gt; has exactly two solutions. Show that Double-SAT is NP-hard.
[[11.5|Solution]]


:11.6. Suppose we are given a subroutine that can solve the traveling salesman decision problem on page 357 in (say) linear time. Give an efficient algorithm to find the actual TSP tour by making a polynomial number of calls to this subroutine.


:[[11.7]]. Implement a SAT to 3-SAT reduction that translates satisfiability instances into equivalent 3-SAT instances.
[[11.7|Solution]]


:11.8. Design and implement a backtracking algorithm to test whether a set of clause sets is satisfiable. What criteria can you use to prune this search?


:[[11.9]]. Implement the vertex cover to satisfiability reduction, and run the resulting clauses through a satisfiability solver code. Does this seem like a practical way to compute things?
[[11.9|Solution]]

===Basic Reductions===

:11.10. An instance of the ''set cover'' problem consists of a set &lt;math&gt;X&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; elements, a family &lt;math&gt;F&lt;/math&gt; of subsets of &lt;math&gt;X&lt;/math&gt;, and an integer &lt;math&gt;k&lt;/math&gt;. The question is, does there exist &lt;math&gt;k&lt;/math&gt; subsets from &lt;math&gt;F&lt;/math&gt; whose union is &lt;math&gt;X&lt;/math&gt;? For example, if &lt;math&gt;X = \{1,2,3,4\}&lt;/math&gt; and &lt;math&gt;F = \{ \{1,2\}, \{2,3\}, \{4\}, \{2,4\} \}&lt;/math&gt;, there does not exist a solution for &lt;math&gt;k=2&lt;/math&gt;, but there does for &lt;math&gt;k=3&lt;/math&gt; (for example, &lt;math&gt; \{1,2\}, \{2,3\}, \{4\}&lt;/math&gt;). Prove that set cover is NP-complete with a reduction from vertex cover.


:[[11.11]]. The ''baseball card collector problem'' is as follows. Given packets &lt;math&gt;P_1, \ldots, P_m&lt;/math&gt;, each of which contains a subset of this year's baseball cards, is it possible to collect all the year's cards by buying &lt;math&gt;\leq k&lt;/math&gt; packets? For example, if the players are &lt;math&gt; \{Aaron, Mays, Ruth, Steven \} &lt;/math&gt; and the packets are
:::&lt;math&gt; \{ \{Aaron,Mays\}, \{Mays,Ruth\}, \{Steven\}, \{Mays,Steven\} \}, &lt;/math&gt; 
:there does not exist a solution for &lt;math&gt;k=2&lt;/math&gt;, but there does for &lt;math&gt;k=3&lt;/math&gt;, such as 
:::&lt;math&gt; \{Aaron,Mays\}, \{Mays,Ruth\}, \{Steven\} &lt;/math&gt; 
:Prove that the baseball card collector problem is NP hard using a reduction from vertex cover.


:11.12. The ''low-degree spanning tree problem'' is as follows. Given a graph &lt;math&gt;G&lt;/math&gt; and an integer &lt;math&gt;k&lt;/math&gt;, does &lt;math&gt;G&lt;/math&gt; contain a spanning tree such that all vertices in the tree have degree ''at most'' &lt;math&gt;k&lt;/math&gt; (obviously, only tree edges count towards the degree)? For example, in the following graph, there is no spanning tree such that all vertices have a degree less than three.
\fixedfigsize{pictures/lowdegree.png}{1.0in}
#Prove that the low-degree spanning tree problem is NP-hard with a reduction from Hamiltonian ''path''. 
#Now consider the ''high-degree spanning tree problem'', which is as follows. Given a graph &lt;math&gt;G&lt;/math&gt; and an integer &lt;math&gt;k&lt;/math&gt;, does &lt;math&gt;G&lt;/math&gt; contain a spanning tree whose highest degree vertex is ''at least'' &lt;math&gt;k&lt;/math&gt;? In the previous example, there exists a spanning tree with a highest degree of 8. Give an efficient algorithm to solve the high-degree spanning tree problem, and an analysis of its time complexity.


:[[11.13]].In the minimum element set cover problem, we seek a set cover &lt;math&gt;S \subseteq C&lt;/math&gt; of a universal set &lt;math&gt;U = {1, . . . , n}&lt;/math&gt; such that sum of the sizes of the subsets in &lt;math&gt;S&lt;/math&gt; is at most &lt;math&gt;k&lt;/math&gt;. 
::(a) Show that &lt;math&gt;C = {{1, 2, 3}, {1, 3, 4}, {2, 3, 4}, {3, 4, 5}}&lt;/math&gt; has a cover of size 6, but none of size 5 because of a repeated element. 
::(b) Prove that this problem is NP-hard. (Hint: set cover remains hard if all subsets are of the same size.)
[[11.13|Solution]]


:11.14. The ''half-Hamiltonian cycle problem'' is, given a graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices, determine whether &lt;math&gt;G&lt;/math&gt; has a simple cycle of length exactly &lt;math&gt;[n/2]&lt;/math&gt;, where the floor function rounds its input down to the nearest integer. Prove that this problem is NP-hard.


:[[11.15]]. The 3-phase power balance problem asks for a way to partition a set of n positive integers into three sets &lt;math&gt;A&lt;/math&gt;, &lt;math&gt;B&lt;/math&gt;, or &lt;math&gt;C&lt;/math&gt; such that &lt;math&gt;\sum_{i} a_i = \sum_{i} b_i = \sum_{i} c_i&lt;/math&gt;. Prove that this problem is NP-hard using a reduction from integer partition or subset sum (see Section 10.5 (page 329)).
[[11.15|Solution]]


:11.16. Show that the following problem is NP-complete:
:* ''Problem:'' Dense subgraph
:* ''Input:'' A graph &lt;math&gt;G&lt;/math&gt;, and integers &lt;math&gt;k&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;G&lt;/math&gt; contain a subgraph with exactly &lt;math&gt;k&lt;/math&gt; vertices and at least &lt;math&gt;y&lt;/math&gt; edges?


:[[11.17]]. Show that the following problem is NP-complete:
:* ''Problem:'' Clique, no-clique
:* ''Input:'' An undirected graph &lt;math&gt;G=(V,E)&lt;/math&gt; and an integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;G&lt;/math&gt; contain both a clique of size &lt;math&gt;k&lt;/math&gt; and an independent set of size &lt;math&gt;k&lt;/math&gt;.
[[11.17|Solution]]


:11.18. n ''Eulerian cycle'' is a tour that visits every edge in a graph exactly once. An ''Eulerian subgraph'' is a subset of the edges and vertices of a graph that has an Eulerian cycle. Prove that the problem of finding the number of edges in the largest Eulerian subgraph of a graph is NP-hard. (Hint: the Hamiltonian circuit problem is NP-hard even if each vertex in the graph is incident upon exactly three edges.)


:[[11.19]]. Show that the following problem is NP-hard:
:*''Problem:'' Maximum Common Subgraph
:*''Input:'' Two graphs &lt;math&gt;G_1 = (V_1, E_1)&lt;/math&gt; and &lt;math&gt;G_2 = (V_2, E_2)&lt;/math&gt;, and a budget &lt;math&gt;b&lt;/math&gt;.
:*Output: Two sets of nodes &lt;math&gt;S_1 \subseteq V_1&lt;/math&gt; and &lt;math&gt;S_2 \subseteq V_2&lt;/math&gt; whose deletion leaves at least &lt;math&gt;b&lt;/math&gt; nodes in each graph, and makes the two graphs identical.
[[11.19|Solution]]


:11.20. A ''strongly independent'' set is a subset of vertices &lt;math&gt;S&lt;/math&gt; in a graph &lt;math&gt;G&lt;/math&gt; such that for any two vertices in &lt;math&gt;S&lt;/math&gt;, there is no path of length two in &lt;math&gt;G&lt;/math&gt;. Prove that strongly independent set is NP-hard.


:[[11.21]]. A ''kite'' is a graph on an even number of vertices, say &lt;math&gt;2n&lt;/math&gt;, in which &lt;math&gt;n&lt;/math&gt; of the vertices form a clique and the remaining &lt;math&gt;n&lt;/math&gt; vertices are connected in a tail that consists of a path joined to one of the vertices of the clique. Given a graph and a goal g, the ''max kite'' problem asks for a subgraph that is a kite and contains &lt;math&gt;2g&lt;/math&gt; nodes. Prove that ''max kite'' is NP-hard.
[[11.21|Solution]]

===Creatvie Reductions===

:11.22


:[[11.23]]


:11.24


:[[11.25]]


:11.26


:[[11.27]]


:11.28


:[[11.29]]


:11.30


===Algorithms for Special Cases===

:[[11.31]]


:11.32


:[[11.33]]


:11.34


:[[11.35]]


Back to [[Chapter List]]</text>
      <sha1>epy4dlvva27hfo5yv8rw0r7o500ewfr</sha1>
    </revision>
    <revision>
      <id>190</id>
      <parentid>189</parentid>
      <timestamp>2020-09-11T19:00:54Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Creatvie Reductions */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="11493">=NP-Completeness=

===Transformations and Satisfiability===

:[[11.1]]. Give the 3-SAT formula that results from applying the reduction of SAT to 3-SAT for the formula: 
:::&lt;math&gt; (x\or y \or \overline z \or w \or u \or \overline v) \and (\overline x \or \overline 
y \or z \or \overline w \or u \or v) \and (x \or \overline y \or \overline z \or w \or u \or \overline v)\and (x \or \overline y) &lt;/math&gt;
[[11.1|Solution]]


:11.2. Draw the graph that results from the reduction of 3-SAT to vertex cover for the expression 
:::&lt;math&gt;(x \or \overline y \or z) \and (\overline x \or y \or \overline z) \and(\overline x \or y \or z) \and (x \or \overline y \or \overline x) &lt;/math&gt;


:[[11.3]]. Prove that 4-SAT is NP-hard.
[[11.3|Solution]]


:11.4. ''Stingy'' SAT is the following problem: given a set of clauses (each a disjunction of literals) and an integer &lt;math&gt;k&lt;/math&gt;, find a satisfying assignment in which at most &lt;math&gt;k&lt;/math&gt; variables are true, if such an assignment exists. Prove that stingy SAT is NP-hard.


:[[11.5]]. The ''Double SAT'' problem asks whether a given satisfiability problem has '''at least two different satisfying assignments'''. For example, the problem &lt;math&gt;{{v1, v2}, {v_1, v_2}, {v_1, v_2}}&lt;/math&gt; is satisfiable, but has only one solution &lt;math&gt;(v_1 =F, v_2 = T)&lt;/math&gt;. In contrast, &lt;math&gt;{{v_1, v_2}, {v_1, v_2}}&lt;/math&gt; has exactly two solutions. Show that Double-SAT is NP-hard.
[[11.5|Solution]]


:11.6. Suppose we are given a subroutine that can solve the traveling salesman decision problem on page 357 in (say) linear time. Give an efficient algorithm to find the actual TSP tour by making a polynomial number of calls to this subroutine.


:[[11.7]]. Implement a SAT to 3-SAT reduction that translates satisfiability instances into equivalent 3-SAT instances.
[[11.7|Solution]]


:11.8. Design and implement a backtracking algorithm to test whether a set of clause sets is satisfiable. What criteria can you use to prune this search?


:[[11.9]]. Implement the vertex cover to satisfiability reduction, and run the resulting clauses through a satisfiability solver code. Does this seem like a practical way to compute things?
[[11.9|Solution]]

===Basic Reductions===

:11.10. An instance of the ''set cover'' problem consists of a set &lt;math&gt;X&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; elements, a family &lt;math&gt;F&lt;/math&gt; of subsets of &lt;math&gt;X&lt;/math&gt;, and an integer &lt;math&gt;k&lt;/math&gt;. The question is, does there exist &lt;math&gt;k&lt;/math&gt; subsets from &lt;math&gt;F&lt;/math&gt; whose union is &lt;math&gt;X&lt;/math&gt;? For example, if &lt;math&gt;X = \{1,2,3,4\}&lt;/math&gt; and &lt;math&gt;F = \{ \{1,2\}, \{2,3\}, \{4\}, \{2,4\} \}&lt;/math&gt;, there does not exist a solution for &lt;math&gt;k=2&lt;/math&gt;, but there does for &lt;math&gt;k=3&lt;/math&gt; (for example, &lt;math&gt; \{1,2\}, \{2,3\}, \{4\}&lt;/math&gt;). Prove that set cover is NP-complete with a reduction from vertex cover.


:[[11.11]]. The ''baseball card collector problem'' is as follows. Given packets &lt;math&gt;P_1, \ldots, P_m&lt;/math&gt;, each of which contains a subset of this year's baseball cards, is it possible to collect all the year's cards by buying &lt;math&gt;\leq k&lt;/math&gt; packets? For example, if the players are &lt;math&gt; \{Aaron, Mays, Ruth, Steven \} &lt;/math&gt; and the packets are
:::&lt;math&gt; \{ \{Aaron,Mays\}, \{Mays,Ruth\}, \{Steven\}, \{Mays,Steven\} \}, &lt;/math&gt; 
:there does not exist a solution for &lt;math&gt;k=2&lt;/math&gt;, but there does for &lt;math&gt;k=3&lt;/math&gt;, such as 
:::&lt;math&gt; \{Aaron,Mays\}, \{Mays,Ruth\}, \{Steven\} &lt;/math&gt; 
:Prove that the baseball card collector problem is NP hard using a reduction from vertex cover.


:11.12. The ''low-degree spanning tree problem'' is as follows. Given a graph &lt;math&gt;G&lt;/math&gt; and an integer &lt;math&gt;k&lt;/math&gt;, does &lt;math&gt;G&lt;/math&gt; contain a spanning tree such that all vertices in the tree have degree ''at most'' &lt;math&gt;k&lt;/math&gt; (obviously, only tree edges count towards the degree)? For example, in the following graph, there is no spanning tree such that all vertices have a degree less than three.
\fixedfigsize{pictures/lowdegree.png}{1.0in}
#Prove that the low-degree spanning tree problem is NP-hard with a reduction from Hamiltonian ''path''. 
#Now consider the ''high-degree spanning tree problem'', which is as follows. Given a graph &lt;math&gt;G&lt;/math&gt; and an integer &lt;math&gt;k&lt;/math&gt;, does &lt;math&gt;G&lt;/math&gt; contain a spanning tree whose highest degree vertex is ''at least'' &lt;math&gt;k&lt;/math&gt;? In the previous example, there exists a spanning tree with a highest degree of 8. Give an efficient algorithm to solve the high-degree spanning tree problem, and an analysis of its time complexity.


:[[11.13]].In the minimum element set cover problem, we seek a set cover &lt;math&gt;S \subseteq C&lt;/math&gt; of a universal set &lt;math&gt;U = {1, . . . , n}&lt;/math&gt; such that sum of the sizes of the subsets in &lt;math&gt;S&lt;/math&gt; is at most &lt;math&gt;k&lt;/math&gt;. 
::(a) Show that &lt;math&gt;C = {{1, 2, 3}, {1, 3, 4}, {2, 3, 4}, {3, 4, 5}}&lt;/math&gt; has a cover of size 6, but none of size 5 because of a repeated element. 
::(b) Prove that this problem is NP-hard. (Hint: set cover remains hard if all subsets are of the same size.)
[[11.13|Solution]]


:11.14. The ''half-Hamiltonian cycle problem'' is, given a graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices, determine whether &lt;math&gt;G&lt;/math&gt; has a simple cycle of length exactly &lt;math&gt;[n/2]&lt;/math&gt;, where the floor function rounds its input down to the nearest integer. Prove that this problem is NP-hard.


:[[11.15]]. The 3-phase power balance problem asks for a way to partition a set of n positive integers into three sets &lt;math&gt;A&lt;/math&gt;, &lt;math&gt;B&lt;/math&gt;, or &lt;math&gt;C&lt;/math&gt; such that &lt;math&gt;\sum_{i} a_i = \sum_{i} b_i = \sum_{i} c_i&lt;/math&gt;. Prove that this problem is NP-hard using a reduction from integer partition or subset sum (see Section 10.5 (page 329)).
[[11.15|Solution]]


:11.16. Show that the following problem is NP-complete:
:* ''Problem:'' Dense subgraph
:* ''Input:'' A graph &lt;math&gt;G&lt;/math&gt;, and integers &lt;math&gt;k&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;G&lt;/math&gt; contain a subgraph with exactly &lt;math&gt;k&lt;/math&gt; vertices and at least &lt;math&gt;y&lt;/math&gt; edges?


:[[11.17]]. Show that the following problem is NP-complete:
:* ''Problem:'' Clique, no-clique
:* ''Input:'' An undirected graph &lt;math&gt;G=(V,E)&lt;/math&gt; and an integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;G&lt;/math&gt; contain both a clique of size &lt;math&gt;k&lt;/math&gt; and an independent set of size &lt;math&gt;k&lt;/math&gt;.
[[11.17|Solution]]


:11.18. n ''Eulerian cycle'' is a tour that visits every edge in a graph exactly once. An ''Eulerian subgraph'' is a subset of the edges and vertices of a graph that has an Eulerian cycle. Prove that the problem of finding the number of edges in the largest Eulerian subgraph of a graph is NP-hard. (Hint: the Hamiltonian circuit problem is NP-hard even if each vertex in the graph is incident upon exactly three edges.)


:[[11.19]]. Show that the following problem is NP-hard:
:*''Problem:'' Maximum Common Subgraph
:*''Input:'' Two graphs &lt;math&gt;G_1 = (V_1, E_1)&lt;/math&gt; and &lt;math&gt;G_2 = (V_2, E_2)&lt;/math&gt;, and a budget &lt;math&gt;b&lt;/math&gt;.
:*Output: Two sets of nodes &lt;math&gt;S_1 \subseteq V_1&lt;/math&gt; and &lt;math&gt;S_2 \subseteq V_2&lt;/math&gt; whose deletion leaves at least &lt;math&gt;b&lt;/math&gt; nodes in each graph, and makes the two graphs identical.
[[11.19|Solution]]


:11.20. A ''strongly independent'' set is a subset of vertices &lt;math&gt;S&lt;/math&gt; in a graph &lt;math&gt;G&lt;/math&gt; such that for any two vertices in &lt;math&gt;S&lt;/math&gt;, there is no path of length two in &lt;math&gt;G&lt;/math&gt;. Prove that strongly independent set is NP-hard.


:[[11.21]]. A ''kite'' is a graph on an even number of vertices, say &lt;math&gt;2n&lt;/math&gt;, in which &lt;math&gt;n&lt;/math&gt; of the vertices form a clique and the remaining &lt;math&gt;n&lt;/math&gt; vertices are connected in a tail that consists of a path joined to one of the vertices of the clique. Given a graph and a goal g, the ''max kite'' problem asks for a subgraph that is a kite and contains &lt;math&gt;2g&lt;/math&gt; nodes. Prove that ''max kite'' is NP-hard.
[[11.21|Solution]]

===Creative Reductions===

:11.22. Prove that the following problem is NP-complete:
:* ''Problem:'' Hitting Set
:* ''Input:'' A collection &lt;math&gt;C&lt;/math&gt; of subsets of a set &lt;math&gt;S&lt;/math&gt;, positive integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;S&lt;/math&gt; contain a subset &lt;math&gt;S'&lt;/math&gt; such that &lt;math&gt;|S'| \leq k&lt;/math&gt; and each subset in &lt;math&gt;C&lt;/math&gt; contains at least one element from &lt;math&gt;S'&lt;/math&gt;?


:[[11.23]]. Prove that the following problem is NP-complete:
:* ''Problem:'' Knapsack
:* ''Input:'' A set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; items, such that the &lt;math&gt;i&lt;/math&gt;th item has value &lt;math&gt;v_i&lt;/math&gt; and weight &lt;math&gt;w_i&lt;/math&gt;.  Two positive integers: weight limit &lt;math&gt;W&lt;/math&gt; and value requirement &lt;math&gt;V&lt;/math&gt;.
:* ''Output:'' Does there exist a subset &lt;math&gt;S' \in S&lt;/math&gt; such that &lt;math&gt;\sum_{i \in S'} w_i \leq W&lt;/math&gt; and &lt;math&gt;\sum_{i \in S'} v_i \geq V&lt;/math&gt;? 
:(Hint: start from integer partition.)
[[11.23|Solution]]


:11.24. Prove that the following problem is NP-complete:
:* ''Problem:'' Hamiltonian Path
:* ''Input:'' A graph &lt;math&gt;G&lt;/math&gt;, and vertices &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;G&lt;/math&gt; contain a path which starts from &lt;math&gt;s&lt;/math&gt;, ends at &lt;math&gt;t&lt;/math&gt;, and visits all vertices without visiting any vertex more than once? (Hint: start from Hamiltonian cycle.)


:[[11.25]]. Prove that the following problem is NP-complete:
:* ''Problem:'' Longest Path
:* ''Input:'' A graph &lt;math&gt;G&lt;/math&gt; and positive integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;G&lt;/math&gt; contain a path that visits at least &lt;math&gt;k&lt;/math&gt; different vertices without visiting any vertex more than once?
[[11.25|Solution]]


:11.26. Prove that the following problem is NP-complete:
:* ''Problem:'' Dominating Set
:* ''Input:'' A graph &lt;math&gt;G=(V,E)&lt;/math&gt; and positive integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Is there a subset &lt;math&gt;V' \in V&lt;/math&gt; such that &lt;math&gt;|V'|\leq k&lt;/math&gt; where for each vertex &lt;math&gt;x \in V&lt;/math&gt; either &lt;math&gt;x \in V'&lt;/math&gt; or there exists an edge &lt;math&gt;(x,y)&lt;/math&gt;, where &lt;math&gt;y \in V'&lt;/math&gt;.


:[[11.27]]. Prove that the vertex cover problem (does there exist a subset &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;k&lt;/math&gt; vertices in a graph &lt;math&gt;G&lt;/math&gt; such that every edge in &lt;math&gt;G&lt;/math&gt; is incident upon at least one vertex in &lt;math&gt;S&lt;/math&gt;?) remains NP-complete even when all the vertices in the graph are restricted to have even degrees.
[[11.27|Solution]]


:11.28. Prove that the following problem is NP-complete:
:* ''Problem:'' Set Packing
:* ''Input:'' A collection &lt;math&gt;C&lt;/math&gt; of subsets of a set &lt;math&gt;S&lt;/math&gt;, positive integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;S&lt;/math&gt; contain at least &lt;math&gt;k&lt;/math&gt; disjoint subsets (i.e., such that none of these subsets have any elements in common?)


:[[11.29]]. Prove that the following problem is NP-complete:
:* ''Problem:'' Feedback Vertex Set
:* ''Input:'' A directed graph &lt;math&gt;G=(V,A)&lt;/math&gt; and positive integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Is there a subset &lt;math&gt;V' \in V&lt;/math&gt; such that &lt;math&gt;|V'|\leq k&lt;/math&gt;, such that deleting the vertices of &lt;math&gt;V'&lt;/math&gt; from &lt;math&gt;G&lt;/math&gt; leaves a DAG?
[[11.29|Solution]]


:11.30. Give a reduction from Sudoku to the vertex coloring problem in graphs. Specifically, describe how to take any partially filled Sudoku board and construct a graph that can be colored with nine colors iff the Sudoku board is solvable.

===Algorithms for Special Cases===

:[[11.31]]


:11.32


:[[11.33]]


:11.34


:[[11.35]]


Back to [[Chapter List]]</text>
      <sha1>myh9c0wfkmcm9mw5xwl25ukju2yuu15</sha1>
    </revision>
    <revision>
      <id>191</id>
      <parentid>190</parentid>
      <timestamp>2020-09-11T19:12:03Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Algorithms for Special Cases */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="13586">=NP-Completeness=

===Transformations and Satisfiability===

:[[11.1]]. Give the 3-SAT formula that results from applying the reduction of SAT to 3-SAT for the formula: 
:::&lt;math&gt; (x\or y \or \overline z \or w \or u \or \overline v) \and (\overline x \or \overline 
y \or z \or \overline w \or u \or v) \and (x \or \overline y \or \overline z \or w \or u \or \overline v)\and (x \or \overline y) &lt;/math&gt;
[[11.1|Solution]]


:11.2. Draw the graph that results from the reduction of 3-SAT to vertex cover for the expression 
:::&lt;math&gt;(x \or \overline y \or z) \and (\overline x \or y \or \overline z) \and(\overline x \or y \or z) \and (x \or \overline y \or \overline x) &lt;/math&gt;


:[[11.3]]. Prove that 4-SAT is NP-hard.
[[11.3|Solution]]


:11.4. ''Stingy'' SAT is the following problem: given a set of clauses (each a disjunction of literals) and an integer &lt;math&gt;k&lt;/math&gt;, find a satisfying assignment in which at most &lt;math&gt;k&lt;/math&gt; variables are true, if such an assignment exists. Prove that stingy SAT is NP-hard.


:[[11.5]]. The ''Double SAT'' problem asks whether a given satisfiability problem has '''at least two different satisfying assignments'''. For example, the problem &lt;math&gt;{{v1, v2}, {v_1, v_2}, {v_1, v_2}}&lt;/math&gt; is satisfiable, but has only one solution &lt;math&gt;(v_1 =F, v_2 = T)&lt;/math&gt;. In contrast, &lt;math&gt;{{v_1, v_2}, {v_1, v_2}}&lt;/math&gt; has exactly two solutions. Show that Double-SAT is NP-hard.
[[11.5|Solution]]


:11.6. Suppose we are given a subroutine that can solve the traveling salesman decision problem on page 357 in (say) linear time. Give an efficient algorithm to find the actual TSP tour by making a polynomial number of calls to this subroutine.


:[[11.7]]. Implement a SAT to 3-SAT reduction that translates satisfiability instances into equivalent 3-SAT instances.
[[11.7|Solution]]


:11.8. Design and implement a backtracking algorithm to test whether a set of clause sets is satisfiable. What criteria can you use to prune this search?


:[[11.9]]. Implement the vertex cover to satisfiability reduction, and run the resulting clauses through a satisfiability solver code. Does this seem like a practical way to compute things?
[[11.9|Solution]]

===Basic Reductions===

:11.10. An instance of the ''set cover'' problem consists of a set &lt;math&gt;X&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; elements, a family &lt;math&gt;F&lt;/math&gt; of subsets of &lt;math&gt;X&lt;/math&gt;, and an integer &lt;math&gt;k&lt;/math&gt;. The question is, does there exist &lt;math&gt;k&lt;/math&gt; subsets from &lt;math&gt;F&lt;/math&gt; whose union is &lt;math&gt;X&lt;/math&gt;? For example, if &lt;math&gt;X = \{1,2,3,4\}&lt;/math&gt; and &lt;math&gt;F = \{ \{1,2\}, \{2,3\}, \{4\}, \{2,4\} \}&lt;/math&gt;, there does not exist a solution for &lt;math&gt;k=2&lt;/math&gt;, but there does for &lt;math&gt;k=3&lt;/math&gt; (for example, &lt;math&gt; \{1,2\}, \{2,3\}, \{4\}&lt;/math&gt;). Prove that set cover is NP-complete with a reduction from vertex cover.


:[[11.11]]. The ''baseball card collector problem'' is as follows. Given packets &lt;math&gt;P_1, \ldots, P_m&lt;/math&gt;, each of which contains a subset of this year's baseball cards, is it possible to collect all the year's cards by buying &lt;math&gt;\leq k&lt;/math&gt; packets? For example, if the players are &lt;math&gt; \{Aaron, Mays, Ruth, Steven \} &lt;/math&gt; and the packets are
:::&lt;math&gt; \{ \{Aaron,Mays\}, \{Mays,Ruth\}, \{Steven\}, \{Mays,Steven\} \}, &lt;/math&gt; 
:there does not exist a solution for &lt;math&gt;k=2&lt;/math&gt;, but there does for &lt;math&gt;k=3&lt;/math&gt;, such as 
:::&lt;math&gt; \{Aaron,Mays\}, \{Mays,Ruth\}, \{Steven\} &lt;/math&gt; 
:Prove that the baseball card collector problem is NP hard using a reduction from vertex cover.


:11.12. The ''low-degree spanning tree problem'' is as follows. Given a graph &lt;math&gt;G&lt;/math&gt; and an integer &lt;math&gt;k&lt;/math&gt;, does &lt;math&gt;G&lt;/math&gt; contain a spanning tree such that all vertices in the tree have degree ''at most'' &lt;math&gt;k&lt;/math&gt; (obviously, only tree edges count towards the degree)? For example, in the following graph, there is no spanning tree such that all vertices have a degree less than three.
\fixedfigsize{pictures/lowdegree.png}{1.0in}
#Prove that the low-degree spanning tree problem is NP-hard with a reduction from Hamiltonian ''path''. 
#Now consider the ''high-degree spanning tree problem'', which is as follows. Given a graph &lt;math&gt;G&lt;/math&gt; and an integer &lt;math&gt;k&lt;/math&gt;, does &lt;math&gt;G&lt;/math&gt; contain a spanning tree whose highest degree vertex is ''at least'' &lt;math&gt;k&lt;/math&gt;? In the previous example, there exists a spanning tree with a highest degree of 8. Give an efficient algorithm to solve the high-degree spanning tree problem, and an analysis of its time complexity.


:[[11.13]].In the minimum element set cover problem, we seek a set cover &lt;math&gt;S \subseteq C&lt;/math&gt; of a universal set &lt;math&gt;U = {1, . . . , n}&lt;/math&gt; such that sum of the sizes of the subsets in &lt;math&gt;S&lt;/math&gt; is at most &lt;math&gt;k&lt;/math&gt;. 
::(a) Show that &lt;math&gt;C = {{1, 2, 3}, {1, 3, 4}, {2, 3, 4}, {3, 4, 5}}&lt;/math&gt; has a cover of size 6, but none of size 5 because of a repeated element. 
::(b) Prove that this problem is NP-hard. (Hint: set cover remains hard if all subsets are of the same size.)
[[11.13|Solution]]


:11.14. The ''half-Hamiltonian cycle problem'' is, given a graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices, determine whether &lt;math&gt;G&lt;/math&gt; has a simple cycle of length exactly &lt;math&gt;[n/2]&lt;/math&gt;, where the floor function rounds its input down to the nearest integer. Prove that this problem is NP-hard.


:[[11.15]]. The 3-phase power balance problem asks for a way to partition a set of n positive integers into three sets &lt;math&gt;A&lt;/math&gt;, &lt;math&gt;B&lt;/math&gt;, or &lt;math&gt;C&lt;/math&gt; such that &lt;math&gt;\sum_{i} a_i = \sum_{i} b_i = \sum_{i} c_i&lt;/math&gt;. Prove that this problem is NP-hard using a reduction from integer partition or subset sum (see Section 10.5 (page 329)).
[[11.15|Solution]]


:11.16. Show that the following problem is NP-complete:
:* ''Problem:'' Dense subgraph
:* ''Input:'' A graph &lt;math&gt;G&lt;/math&gt;, and integers &lt;math&gt;k&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;G&lt;/math&gt; contain a subgraph with exactly &lt;math&gt;k&lt;/math&gt; vertices and at least &lt;math&gt;y&lt;/math&gt; edges?


:[[11.17]]. Show that the following problem is NP-complete:
:* ''Problem:'' Clique, no-clique
:* ''Input:'' An undirected graph &lt;math&gt;G=(V,E)&lt;/math&gt; and an integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;G&lt;/math&gt; contain both a clique of size &lt;math&gt;k&lt;/math&gt; and an independent set of size &lt;math&gt;k&lt;/math&gt;.
[[11.17|Solution]]


:11.18. n ''Eulerian cycle'' is a tour that visits every edge in a graph exactly once. An ''Eulerian subgraph'' is a subset of the edges and vertices of a graph that has an Eulerian cycle. Prove that the problem of finding the number of edges in the largest Eulerian subgraph of a graph is NP-hard. (Hint: the Hamiltonian circuit problem is NP-hard even if each vertex in the graph is incident upon exactly three edges.)


:[[11.19]]. Show that the following problem is NP-hard:
:*''Problem:'' Maximum Common Subgraph
:*''Input:'' Two graphs &lt;math&gt;G_1 = (V_1, E_1)&lt;/math&gt; and &lt;math&gt;G_2 = (V_2, E_2)&lt;/math&gt;, and a budget &lt;math&gt;b&lt;/math&gt;.
:*Output: Two sets of nodes &lt;math&gt;S_1 \subseteq V_1&lt;/math&gt; and &lt;math&gt;S_2 \subseteq V_2&lt;/math&gt; whose deletion leaves at least &lt;math&gt;b&lt;/math&gt; nodes in each graph, and makes the two graphs identical.
[[11.19|Solution]]


:11.20. A ''strongly independent'' set is a subset of vertices &lt;math&gt;S&lt;/math&gt; in a graph &lt;math&gt;G&lt;/math&gt; such that for any two vertices in &lt;math&gt;S&lt;/math&gt;, there is no path of length two in &lt;math&gt;G&lt;/math&gt;. Prove that strongly independent set is NP-hard.


:[[11.21]]. A ''kite'' is a graph on an even number of vertices, say &lt;math&gt;2n&lt;/math&gt;, in which &lt;math&gt;n&lt;/math&gt; of the vertices form a clique and the remaining &lt;math&gt;n&lt;/math&gt; vertices are connected in a tail that consists of a path joined to one of the vertices of the clique. Given a graph and a goal g, the ''max kite'' problem asks for a subgraph that is a kite and contains &lt;math&gt;2g&lt;/math&gt; nodes. Prove that ''max kite'' is NP-hard.
[[11.21|Solution]]

===Creative Reductions===

:11.22. Prove that the following problem is NP-complete:
:* ''Problem:'' Hitting Set
:* ''Input:'' A collection &lt;math&gt;C&lt;/math&gt; of subsets of a set &lt;math&gt;S&lt;/math&gt;, positive integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;S&lt;/math&gt; contain a subset &lt;math&gt;S'&lt;/math&gt; such that &lt;math&gt;|S'| \leq k&lt;/math&gt; and each subset in &lt;math&gt;C&lt;/math&gt; contains at least one element from &lt;math&gt;S'&lt;/math&gt;?


:[[11.23]]. Prove that the following problem is NP-complete:
:* ''Problem:'' Knapsack
:* ''Input:'' A set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; items, such that the &lt;math&gt;i&lt;/math&gt;th item has value &lt;math&gt;v_i&lt;/math&gt; and weight &lt;math&gt;w_i&lt;/math&gt;.  Two positive integers: weight limit &lt;math&gt;W&lt;/math&gt; and value requirement &lt;math&gt;V&lt;/math&gt;.
:* ''Output:'' Does there exist a subset &lt;math&gt;S' \in S&lt;/math&gt; such that &lt;math&gt;\sum_{i \in S'} w_i \leq W&lt;/math&gt; and &lt;math&gt;\sum_{i \in S'} v_i \geq V&lt;/math&gt;? 
:(Hint: start from integer partition.)
[[11.23|Solution]]


:11.24. Prove that the following problem is NP-complete:
:* ''Problem:'' Hamiltonian Path
:* ''Input:'' A graph &lt;math&gt;G&lt;/math&gt;, and vertices &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;G&lt;/math&gt; contain a path which starts from &lt;math&gt;s&lt;/math&gt;, ends at &lt;math&gt;t&lt;/math&gt;, and visits all vertices without visiting any vertex more than once? (Hint: start from Hamiltonian cycle.)


:[[11.25]]. Prove that the following problem is NP-complete:
:* ''Problem:'' Longest Path
:* ''Input:'' A graph &lt;math&gt;G&lt;/math&gt; and positive integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;G&lt;/math&gt; contain a path that visits at least &lt;math&gt;k&lt;/math&gt; different vertices without visiting any vertex more than once?
[[11.25|Solution]]


:11.26. Prove that the following problem is NP-complete:
:* ''Problem:'' Dominating Set
:* ''Input:'' A graph &lt;math&gt;G=(V,E)&lt;/math&gt; and positive integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Is there a subset &lt;math&gt;V' \in V&lt;/math&gt; such that &lt;math&gt;|V'|\leq k&lt;/math&gt; where for each vertex &lt;math&gt;x \in V&lt;/math&gt; either &lt;math&gt;x \in V'&lt;/math&gt; or there exists an edge &lt;math&gt;(x,y)&lt;/math&gt;, where &lt;math&gt;y \in V'&lt;/math&gt;.


:[[11.27]]. Prove that the vertex cover problem (does there exist a subset &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;k&lt;/math&gt; vertices in a graph &lt;math&gt;G&lt;/math&gt; such that every edge in &lt;math&gt;G&lt;/math&gt; is incident upon at least one vertex in &lt;math&gt;S&lt;/math&gt;?) remains NP-complete even when all the vertices in the graph are restricted to have even degrees.
[[11.27|Solution]]


:11.28. Prove that the following problem is NP-complete:
:* ''Problem:'' Set Packing
:* ''Input:'' A collection &lt;math&gt;C&lt;/math&gt; of subsets of a set &lt;math&gt;S&lt;/math&gt;, positive integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;S&lt;/math&gt; contain at least &lt;math&gt;k&lt;/math&gt; disjoint subsets (i.e., such that none of these subsets have any elements in common?)


:[[11.29]]. Prove that the following problem is NP-complete:
:* ''Problem:'' Feedback Vertex Set
:* ''Input:'' A directed graph &lt;math&gt;G=(V,A)&lt;/math&gt; and positive integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Is there a subset &lt;math&gt;V' \in V&lt;/math&gt; such that &lt;math&gt;|V'|\leq k&lt;/math&gt;, such that deleting the vertices of &lt;math&gt;V'&lt;/math&gt; from &lt;math&gt;G&lt;/math&gt; leaves a DAG?
[[11.29|Solution]]


:11.30. Give a reduction from Sudoku to the vertex coloring problem in graphs. Specifically, describe how to take any partially filled Sudoku board and construct a graph that can be colored with nine colors iff the Sudoku board is solvable.

===Algorithms for Special Cases===

:[[11.31]]. A Hamiltonian path &lt;math&gt;P&lt;/math&gt; is a path that visits each vertex exactly once. The problem of testing whether a graph &lt;math&gt;G&lt;/math&gt; contains a Hamiltonian path is NP-complete.
There does not have to be an edge in &lt;math&gt;G&lt;/math&gt; from the ending vertex to the starting vertex of &lt;math&gt;P&lt;/math&gt;, unlike in the Hamiltonian cycle problem. Give an &lt;math&gt;O(n+m)&lt;/math&gt;-time algorithm to test whether a directed acyclic graph &lt;math&gt;G&lt;/math&gt; (a DAG) contains a Hamiltonian path. (Hint: think about topological sorting and DFS.)
[[11.31|Solution]]


:11.32. Consider the ''k''-clique problem, which is the general clique problem restricted to graphs in which every vertex has degree at most &lt;math&gt;k&lt;/math&gt;. Prove that ''k''-clique has an efficient algorithm for any given &lt;math&gt;k&lt;/math&gt;, meaning that &lt;math&gt;k&lt;/math&gt; is a constant.


:[[11.33]]. The &lt;math&gt;2&lt;/math&gt;-SAT problem is, given a Boolean formula in 2-conjunctive normal form (CNF), to decide whether the formula is satisfiable. &lt;math&gt;2&lt;/math&gt;-SAT is like &lt;math&gt;3&lt;/math&gt;-SAT, except that each clause can have only two literals. For example, the following formula is in &lt;math&gt;2&lt;/math&gt;-CNF: &lt;math&gt; (x_1 \or x_2) \and (\bar{x}_2 \or x_3) \and (x_1 \or \bar{x}_3) &lt;/math&gt; 
:Give a polynomial-time algorithm to solve &lt;math&gt;2&lt;/math&gt;-SAT.
[[11.33|Solution]]


:11.34, Show that the following problems are in NP:
#Does graph &lt;math&gt;G&lt;/math&gt; have a simple path (i.e., with no vertex repeated) of length &lt;math&gt;k&lt;/math&gt;? \#Is integer &lt;math&gt;n&lt;/math&gt; composite (i.e., not prime)? 
#Does graph &lt;math&gt;G&lt;/math&gt; have a vertex cover of size &lt;math&gt;k&lt;/math&gt;?


:[[11.35]]. Until 2002, it was an open question whether the decision problem ''Is integer &lt;math&gt;n&lt;/math&gt; a composite number, in other words, not prime?'' can be computed in time polynomial in the size of its input. Why doesn't the following algorithm suffice to prove it is in P, since it runs in &lt;math&gt;O(n)&lt;/math&gt; time?
   PrimalityTesting(&lt;math&gt;n&lt;/math&gt;)
      composite := &lt;math&gt;false&lt;/math&gt;
      for i := 2 to &lt;math&gt;n-1&lt;/math&gt; do
         if &lt;math&gt;(n\,\bmod\,i) = 0&lt;/math&gt; then
            composite := &lt;math&gt;true&lt;/math&gt;
[[11.35|Solution]]


Back to [[Chapter List]]</text>
      <sha1>r3svix59n0r0qbcfq6gomdccreyxbfi</sha1>
    </revision>
    <revision>
      <id>192</id>
      <parentid>191</parentid>
      <timestamp>2020-09-11T19:13:39Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Basic Reductions */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="13605">=NP-Completeness=

===Transformations and Satisfiability===

:[[11.1]]. Give the 3-SAT formula that results from applying the reduction of SAT to 3-SAT for the formula: 
:::&lt;math&gt; (x\or y \or \overline z \or w \or u \or \overline v) \and (\overline x \or \overline 
y \or z \or \overline w \or u \or v) \and (x \or \overline y \or \overline z \or w \or u \or \overline v)\and (x \or \overline y) &lt;/math&gt;
[[11.1|Solution]]


:11.2. Draw the graph that results from the reduction of 3-SAT to vertex cover for the expression 
:::&lt;math&gt;(x \or \overline y \or z) \and (\overline x \or y \or \overline z) \and(\overline x \or y \or z) \and (x \or \overline y \or \overline x) &lt;/math&gt;


:[[11.3]]. Prove that 4-SAT is NP-hard.
[[11.3|Solution]]


:11.4. ''Stingy'' SAT is the following problem: given a set of clauses (each a disjunction of literals) and an integer &lt;math&gt;k&lt;/math&gt;, find a satisfying assignment in which at most &lt;math&gt;k&lt;/math&gt; variables are true, if such an assignment exists. Prove that stingy SAT is NP-hard.


:[[11.5]]. The ''Double SAT'' problem asks whether a given satisfiability problem has '''at least two different satisfying assignments'''. For example, the problem &lt;math&gt;{{v1, v2}, {v_1, v_2}, {v_1, v_2}}&lt;/math&gt; is satisfiable, but has only one solution &lt;math&gt;(v_1 =F, v_2 = T)&lt;/math&gt;. In contrast, &lt;math&gt;{{v_1, v_2}, {v_1, v_2}}&lt;/math&gt; has exactly two solutions. Show that Double-SAT is NP-hard.
[[11.5|Solution]]


:11.6. Suppose we are given a subroutine that can solve the traveling salesman decision problem on page 357 in (say) linear time. Give an efficient algorithm to find the actual TSP tour by making a polynomial number of calls to this subroutine.


:[[11.7]]. Implement a SAT to 3-SAT reduction that translates satisfiability instances into equivalent 3-SAT instances.
[[11.7|Solution]]


:11.8. Design and implement a backtracking algorithm to test whether a set of clause sets is satisfiable. What criteria can you use to prune this search?


:[[11.9]]. Implement the vertex cover to satisfiability reduction, and run the resulting clauses through a satisfiability solver code. Does this seem like a practical way to compute things?
[[11.9|Solution]]

===Basic Reductions===

:11.10. An instance of the ''set cover'' problem consists of a set &lt;math&gt;X&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; elements, a family &lt;math&gt;F&lt;/math&gt; of subsets of &lt;math&gt;X&lt;/math&gt;, and an integer &lt;math&gt;k&lt;/math&gt;. The question is, does there exist &lt;math&gt;k&lt;/math&gt; subsets from &lt;math&gt;F&lt;/math&gt; whose union is &lt;math&gt;X&lt;/math&gt;? For example, if &lt;math&gt;X = \{1,2,3,4\}&lt;/math&gt; and &lt;math&gt;F = \{ \{1,2\}, \{2,3\}, \{4\}, \{2,4\} \}&lt;/math&gt;, there does not exist a solution for &lt;math&gt;k=2&lt;/math&gt;, but there does for &lt;math&gt;k=3&lt;/math&gt; (for example, &lt;math&gt; \{1,2\}, \{2,3\}, \{4\}&lt;/math&gt;). Prove that set cover is NP-complete with a reduction from vertex cover.


:[[11.11]]. The ''baseball card collector problem'' is as follows. Given packets &lt;math&gt;P_1, \ldots, P_m&lt;/math&gt;, each of which contains a subset of this year's baseball cards, is it possible to collect all the year's cards by buying &lt;math&gt;\leq k&lt;/math&gt; packets? For example, if the players are &lt;math&gt; \{Aaron, Mays, Ruth, Steven \} &lt;/math&gt; and the packets are
:::&lt;math&gt; \{ \{Aaron,Mays\}, \{Mays,Ruth\}, \{Steven\}, \{Mays,Steven\} \}, &lt;/math&gt; 
:there does not exist a solution for &lt;math&gt;k=2&lt;/math&gt;, but there does for &lt;math&gt;k=3&lt;/math&gt;, such as 
:::&lt;math&gt; \{Aaron,Mays\}, \{Mays,Ruth\}, \{Steven\} &lt;/math&gt; 
:Prove that the baseball card collector problem is NP hard using a reduction from vertex cover.
[[11.11|Solution]]


:11.12. The ''low-degree spanning tree problem'' is as follows. Given a graph &lt;math&gt;G&lt;/math&gt; and an integer &lt;math&gt;k&lt;/math&gt;, does &lt;math&gt;G&lt;/math&gt; contain a spanning tree such that all vertices in the tree have degree ''at most'' &lt;math&gt;k&lt;/math&gt; (obviously, only tree edges count towards the degree)? For example, in the following graph, there is no spanning tree such that all vertices have a degree less than three.
\fixedfigsize{pictures/lowdegree.png}{1.0in}
#Prove that the low-degree spanning tree problem is NP-hard with a reduction from Hamiltonian ''path''. 
#Now consider the ''high-degree spanning tree problem'', which is as follows. Given a graph &lt;math&gt;G&lt;/math&gt; and an integer &lt;math&gt;k&lt;/math&gt;, does &lt;math&gt;G&lt;/math&gt; contain a spanning tree whose highest degree vertex is ''at least'' &lt;math&gt;k&lt;/math&gt;? In the previous example, there exists a spanning tree with a highest degree of 8. Give an efficient algorithm to solve the high-degree spanning tree problem, and an analysis of its time complexity.


:[[11.13]].In the minimum element set cover problem, we seek a set cover &lt;math&gt;S \subseteq C&lt;/math&gt; of a universal set &lt;math&gt;U = {1, . . . , n}&lt;/math&gt; such that sum of the sizes of the subsets in &lt;math&gt;S&lt;/math&gt; is at most &lt;math&gt;k&lt;/math&gt;. 
::(a) Show that &lt;math&gt;C = {{1, 2, 3}, {1, 3, 4}, {2, 3, 4}, {3, 4, 5}}&lt;/math&gt; has a cover of size 6, but none of size 5 because of a repeated element. 
::(b) Prove that this problem is NP-hard. (Hint: set cover remains hard if all subsets are of the same size.)
[[11.13|Solution]]


:11.14. The ''half-Hamiltonian cycle problem'' is, given a graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices, determine whether &lt;math&gt;G&lt;/math&gt; has a simple cycle of length exactly &lt;math&gt;[n/2]&lt;/math&gt;, where the floor function rounds its input down to the nearest integer. Prove that this problem is NP-hard.


:[[11.15]]. The 3-phase power balance problem asks for a way to partition a set of n positive integers into three sets &lt;math&gt;A&lt;/math&gt;, &lt;math&gt;B&lt;/math&gt;, or &lt;math&gt;C&lt;/math&gt; such that &lt;math&gt;\sum_{i} a_i = \sum_{i} b_i = \sum_{i} c_i&lt;/math&gt;. Prove that this problem is NP-hard using a reduction from integer partition or subset sum (see Section 10.5 (page 329)).
[[11.15|Solution]]


:11.16. Show that the following problem is NP-complete:
:* ''Problem:'' Dense subgraph
:* ''Input:'' A graph &lt;math&gt;G&lt;/math&gt;, and integers &lt;math&gt;k&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;G&lt;/math&gt; contain a subgraph with exactly &lt;math&gt;k&lt;/math&gt; vertices and at least &lt;math&gt;y&lt;/math&gt; edges?


:[[11.17]]. Show that the following problem is NP-complete:
:* ''Problem:'' Clique, no-clique
:* ''Input:'' An undirected graph &lt;math&gt;G=(V,E)&lt;/math&gt; and an integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;G&lt;/math&gt; contain both a clique of size &lt;math&gt;k&lt;/math&gt; and an independent set of size &lt;math&gt;k&lt;/math&gt;.
[[11.17|Solution]]


:11.18. n ''Eulerian cycle'' is a tour that visits every edge in a graph exactly once. An ''Eulerian subgraph'' is a subset of the edges and vertices of a graph that has an Eulerian cycle. Prove that the problem of finding the number of edges in the largest Eulerian subgraph of a graph is NP-hard. (Hint: the Hamiltonian circuit problem is NP-hard even if each vertex in the graph is incident upon exactly three edges.)


:[[11.19]]. Show that the following problem is NP-hard:
:*''Problem:'' Maximum Common Subgraph
:*''Input:'' Two graphs &lt;math&gt;G_1 = (V_1, E_1)&lt;/math&gt; and &lt;math&gt;G_2 = (V_2, E_2)&lt;/math&gt;, and a budget &lt;math&gt;b&lt;/math&gt;.
:*Output: Two sets of nodes &lt;math&gt;S_1 \subseteq V_1&lt;/math&gt; and &lt;math&gt;S_2 \subseteq V_2&lt;/math&gt; whose deletion leaves at least &lt;math&gt;b&lt;/math&gt; nodes in each graph, and makes the two graphs identical.
[[11.19|Solution]]


:11.20. A ''strongly independent'' set is a subset of vertices &lt;math&gt;S&lt;/math&gt; in a graph &lt;math&gt;G&lt;/math&gt; such that for any two vertices in &lt;math&gt;S&lt;/math&gt;, there is no path of length two in &lt;math&gt;G&lt;/math&gt;. Prove that strongly independent set is NP-hard.


:[[11.21]]. A ''kite'' is a graph on an even number of vertices, say &lt;math&gt;2n&lt;/math&gt;, in which &lt;math&gt;n&lt;/math&gt; of the vertices form a clique and the remaining &lt;math&gt;n&lt;/math&gt; vertices are connected in a tail that consists of a path joined to one of the vertices of the clique. Given a graph and a goal g, the ''max kite'' problem asks for a subgraph that is a kite and contains &lt;math&gt;2g&lt;/math&gt; nodes. Prove that ''max kite'' is NP-hard.
[[11.21|Solution]]

===Creative Reductions===

:11.22. Prove that the following problem is NP-complete:
:* ''Problem:'' Hitting Set
:* ''Input:'' A collection &lt;math&gt;C&lt;/math&gt; of subsets of a set &lt;math&gt;S&lt;/math&gt;, positive integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;S&lt;/math&gt; contain a subset &lt;math&gt;S'&lt;/math&gt; such that &lt;math&gt;|S'| \leq k&lt;/math&gt; and each subset in &lt;math&gt;C&lt;/math&gt; contains at least one element from &lt;math&gt;S'&lt;/math&gt;?


:[[11.23]]. Prove that the following problem is NP-complete:
:* ''Problem:'' Knapsack
:* ''Input:'' A set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; items, such that the &lt;math&gt;i&lt;/math&gt;th item has value &lt;math&gt;v_i&lt;/math&gt; and weight &lt;math&gt;w_i&lt;/math&gt;.  Two positive integers: weight limit &lt;math&gt;W&lt;/math&gt; and value requirement &lt;math&gt;V&lt;/math&gt;.
:* ''Output:'' Does there exist a subset &lt;math&gt;S' \in S&lt;/math&gt; such that &lt;math&gt;\sum_{i \in S'} w_i \leq W&lt;/math&gt; and &lt;math&gt;\sum_{i \in S'} v_i \geq V&lt;/math&gt;? 
:(Hint: start from integer partition.)
[[11.23|Solution]]


:11.24. Prove that the following problem is NP-complete:
:* ''Problem:'' Hamiltonian Path
:* ''Input:'' A graph &lt;math&gt;G&lt;/math&gt;, and vertices &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;G&lt;/math&gt; contain a path which starts from &lt;math&gt;s&lt;/math&gt;, ends at &lt;math&gt;t&lt;/math&gt;, and visits all vertices without visiting any vertex more than once? (Hint: start from Hamiltonian cycle.)


:[[11.25]]. Prove that the following problem is NP-complete:
:* ''Problem:'' Longest Path
:* ''Input:'' A graph &lt;math&gt;G&lt;/math&gt; and positive integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;G&lt;/math&gt; contain a path that visits at least &lt;math&gt;k&lt;/math&gt; different vertices without visiting any vertex more than once?
[[11.25|Solution]]


:11.26. Prove that the following problem is NP-complete:
:* ''Problem:'' Dominating Set
:* ''Input:'' A graph &lt;math&gt;G=(V,E)&lt;/math&gt; and positive integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Is there a subset &lt;math&gt;V' \in V&lt;/math&gt; such that &lt;math&gt;|V'|\leq k&lt;/math&gt; where for each vertex &lt;math&gt;x \in V&lt;/math&gt; either &lt;math&gt;x \in V'&lt;/math&gt; or there exists an edge &lt;math&gt;(x,y)&lt;/math&gt;, where &lt;math&gt;y \in V'&lt;/math&gt;.


:[[11.27]]. Prove that the vertex cover problem (does there exist a subset &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;k&lt;/math&gt; vertices in a graph &lt;math&gt;G&lt;/math&gt; such that every edge in &lt;math&gt;G&lt;/math&gt; is incident upon at least one vertex in &lt;math&gt;S&lt;/math&gt;?) remains NP-complete even when all the vertices in the graph are restricted to have even degrees.
[[11.27|Solution]]


:11.28. Prove that the following problem is NP-complete:
:* ''Problem:'' Set Packing
:* ''Input:'' A collection &lt;math&gt;C&lt;/math&gt; of subsets of a set &lt;math&gt;S&lt;/math&gt;, positive integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;S&lt;/math&gt; contain at least &lt;math&gt;k&lt;/math&gt; disjoint subsets (i.e., such that none of these subsets have any elements in common?)


:[[11.29]]. Prove that the following problem is NP-complete:
:* ''Problem:'' Feedback Vertex Set
:* ''Input:'' A directed graph &lt;math&gt;G=(V,A)&lt;/math&gt; and positive integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Is there a subset &lt;math&gt;V' \in V&lt;/math&gt; such that &lt;math&gt;|V'|\leq k&lt;/math&gt;, such that deleting the vertices of &lt;math&gt;V'&lt;/math&gt; from &lt;math&gt;G&lt;/math&gt; leaves a DAG?
[[11.29|Solution]]


:11.30. Give a reduction from Sudoku to the vertex coloring problem in graphs. Specifically, describe how to take any partially filled Sudoku board and construct a graph that can be colored with nine colors iff the Sudoku board is solvable.

===Algorithms for Special Cases===

:[[11.31]]. A Hamiltonian path &lt;math&gt;P&lt;/math&gt; is a path that visits each vertex exactly once. The problem of testing whether a graph &lt;math&gt;G&lt;/math&gt; contains a Hamiltonian path is NP-complete.
There does not have to be an edge in &lt;math&gt;G&lt;/math&gt; from the ending vertex to the starting vertex of &lt;math&gt;P&lt;/math&gt;, unlike in the Hamiltonian cycle problem. Give an &lt;math&gt;O(n+m)&lt;/math&gt;-time algorithm to test whether a directed acyclic graph &lt;math&gt;G&lt;/math&gt; (a DAG) contains a Hamiltonian path. (Hint: think about topological sorting and DFS.)
[[11.31|Solution]]


:11.32. Consider the ''k''-clique problem, which is the general clique problem restricted to graphs in which every vertex has degree at most &lt;math&gt;k&lt;/math&gt;. Prove that ''k''-clique has an efficient algorithm for any given &lt;math&gt;k&lt;/math&gt;, meaning that &lt;math&gt;k&lt;/math&gt; is a constant.


:[[11.33]]. The &lt;math&gt;2&lt;/math&gt;-SAT problem is, given a Boolean formula in 2-conjunctive normal form (CNF), to decide whether the formula is satisfiable. &lt;math&gt;2&lt;/math&gt;-SAT is like &lt;math&gt;3&lt;/math&gt;-SAT, except that each clause can have only two literals. For example, the following formula is in &lt;math&gt;2&lt;/math&gt;-CNF: &lt;math&gt; (x_1 \or x_2) \and (\bar{x}_2 \or x_3) \and (x_1 \or \bar{x}_3) &lt;/math&gt; 
:Give a polynomial-time algorithm to solve &lt;math&gt;2&lt;/math&gt;-SAT.
[[11.33|Solution]]


:11.34, Show that the following problems are in NP:
#Does graph &lt;math&gt;G&lt;/math&gt; have a simple path (i.e., with no vertex repeated) of length &lt;math&gt;k&lt;/math&gt;? \#Is integer &lt;math&gt;n&lt;/math&gt; composite (i.e., not prime)? 
#Does graph &lt;math&gt;G&lt;/math&gt; have a vertex cover of size &lt;math&gt;k&lt;/math&gt;?


:[[11.35]]. Until 2002, it was an open question whether the decision problem ''Is integer &lt;math&gt;n&lt;/math&gt; a composite number, in other words, not prime?'' can be computed in time polynomial in the size of its input. Why doesn't the following algorithm suffice to prove it is in P, since it runs in &lt;math&gt;O(n)&lt;/math&gt; time?
   PrimalityTesting(&lt;math&gt;n&lt;/math&gt;)
      composite := &lt;math&gt;false&lt;/math&gt;
      for i := 2 to &lt;math&gt;n-1&lt;/math&gt; do
         if &lt;math&gt;(n\,\bmod\,i) = 0&lt;/math&gt; then
            composite := &lt;math&gt;true&lt;/math&gt;
[[11.35|Solution]]


Back to [[Chapter List]]</text>
      <sha1>av53xq17y1lus1vnzl9jau58y5b8ky8</sha1>
    </revision>
    <revision>
      <id>204</id>
      <parentid>192</parentid>
      <timestamp>2020-09-11T22:08:11Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Algorithms for Special Cases */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="13605">=NP-Completeness=

===Transformations and Satisfiability===

:[[11.1]]. Give the 3-SAT formula that results from applying the reduction of SAT to 3-SAT for the formula: 
:::&lt;math&gt; (x\or y \or \overline z \or w \or u \or \overline v) \and (\overline x \or \overline 
y \or z \or \overline w \or u \or v) \and (x \or \overline y \or \overline z \or w \or u \or \overline v)\and (x \or \overline y) &lt;/math&gt;
[[11.1|Solution]]


:11.2. Draw the graph that results from the reduction of 3-SAT to vertex cover for the expression 
:::&lt;math&gt;(x \or \overline y \or z) \and (\overline x \or y \or \overline z) \and(\overline x \or y \or z) \and (x \or \overline y \or \overline x) &lt;/math&gt;


:[[11.3]]. Prove that 4-SAT is NP-hard.
[[11.3|Solution]]


:11.4. ''Stingy'' SAT is the following problem: given a set of clauses (each a disjunction of literals) and an integer &lt;math&gt;k&lt;/math&gt;, find a satisfying assignment in which at most &lt;math&gt;k&lt;/math&gt; variables are true, if such an assignment exists. Prove that stingy SAT is NP-hard.


:[[11.5]]. The ''Double SAT'' problem asks whether a given satisfiability problem has '''at least two different satisfying assignments'''. For example, the problem &lt;math&gt;{{v1, v2}, {v_1, v_2}, {v_1, v_2}}&lt;/math&gt; is satisfiable, but has only one solution &lt;math&gt;(v_1 =F, v_2 = T)&lt;/math&gt;. In contrast, &lt;math&gt;{{v_1, v_2}, {v_1, v_2}}&lt;/math&gt; has exactly two solutions. Show that Double-SAT is NP-hard.
[[11.5|Solution]]


:11.6. Suppose we are given a subroutine that can solve the traveling salesman decision problem on page 357 in (say) linear time. Give an efficient algorithm to find the actual TSP tour by making a polynomial number of calls to this subroutine.


:[[11.7]]. Implement a SAT to 3-SAT reduction that translates satisfiability instances into equivalent 3-SAT instances.
[[11.7|Solution]]


:11.8. Design and implement a backtracking algorithm to test whether a set of clause sets is satisfiable. What criteria can you use to prune this search?


:[[11.9]]. Implement the vertex cover to satisfiability reduction, and run the resulting clauses through a satisfiability solver code. Does this seem like a practical way to compute things?
[[11.9|Solution]]

===Basic Reductions===

:11.10. An instance of the ''set cover'' problem consists of a set &lt;math&gt;X&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; elements, a family &lt;math&gt;F&lt;/math&gt; of subsets of &lt;math&gt;X&lt;/math&gt;, and an integer &lt;math&gt;k&lt;/math&gt;. The question is, does there exist &lt;math&gt;k&lt;/math&gt; subsets from &lt;math&gt;F&lt;/math&gt; whose union is &lt;math&gt;X&lt;/math&gt;? For example, if &lt;math&gt;X = \{1,2,3,4\}&lt;/math&gt; and &lt;math&gt;F = \{ \{1,2\}, \{2,3\}, \{4\}, \{2,4\} \}&lt;/math&gt;, there does not exist a solution for &lt;math&gt;k=2&lt;/math&gt;, but there does for &lt;math&gt;k=3&lt;/math&gt; (for example, &lt;math&gt; \{1,2\}, \{2,3\}, \{4\}&lt;/math&gt;). Prove that set cover is NP-complete with a reduction from vertex cover.


:[[11.11]]. The ''baseball card collector problem'' is as follows. Given packets &lt;math&gt;P_1, \ldots, P_m&lt;/math&gt;, each of which contains a subset of this year's baseball cards, is it possible to collect all the year's cards by buying &lt;math&gt;\leq k&lt;/math&gt; packets? For example, if the players are &lt;math&gt; \{Aaron, Mays, Ruth, Steven \} &lt;/math&gt; and the packets are
:::&lt;math&gt; \{ \{Aaron,Mays\}, \{Mays,Ruth\}, \{Steven\}, \{Mays,Steven\} \}, &lt;/math&gt; 
:there does not exist a solution for &lt;math&gt;k=2&lt;/math&gt;, but there does for &lt;math&gt;k=3&lt;/math&gt;, such as 
:::&lt;math&gt; \{Aaron,Mays\}, \{Mays,Ruth\}, \{Steven\} &lt;/math&gt; 
:Prove that the baseball card collector problem is NP hard using a reduction from vertex cover.
[[11.11|Solution]]


:11.12. The ''low-degree spanning tree problem'' is as follows. Given a graph &lt;math&gt;G&lt;/math&gt; and an integer &lt;math&gt;k&lt;/math&gt;, does &lt;math&gt;G&lt;/math&gt; contain a spanning tree such that all vertices in the tree have degree ''at most'' &lt;math&gt;k&lt;/math&gt; (obviously, only tree edges count towards the degree)? For example, in the following graph, there is no spanning tree such that all vertices have a degree less than three.
\fixedfigsize{pictures/lowdegree.png}{1.0in}
#Prove that the low-degree spanning tree problem is NP-hard with a reduction from Hamiltonian ''path''. 
#Now consider the ''high-degree spanning tree problem'', which is as follows. Given a graph &lt;math&gt;G&lt;/math&gt; and an integer &lt;math&gt;k&lt;/math&gt;, does &lt;math&gt;G&lt;/math&gt; contain a spanning tree whose highest degree vertex is ''at least'' &lt;math&gt;k&lt;/math&gt;? In the previous example, there exists a spanning tree with a highest degree of 8. Give an efficient algorithm to solve the high-degree spanning tree problem, and an analysis of its time complexity.


:[[11.13]].In the minimum element set cover problem, we seek a set cover &lt;math&gt;S \subseteq C&lt;/math&gt; of a universal set &lt;math&gt;U = {1, . . . , n}&lt;/math&gt; such that sum of the sizes of the subsets in &lt;math&gt;S&lt;/math&gt; is at most &lt;math&gt;k&lt;/math&gt;. 
::(a) Show that &lt;math&gt;C = {{1, 2, 3}, {1, 3, 4}, {2, 3, 4}, {3, 4, 5}}&lt;/math&gt; has a cover of size 6, but none of size 5 because of a repeated element. 
::(b) Prove that this problem is NP-hard. (Hint: set cover remains hard if all subsets are of the same size.)
[[11.13|Solution]]


:11.14. The ''half-Hamiltonian cycle problem'' is, given a graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices, determine whether &lt;math&gt;G&lt;/math&gt; has a simple cycle of length exactly &lt;math&gt;[n/2]&lt;/math&gt;, where the floor function rounds its input down to the nearest integer. Prove that this problem is NP-hard.


:[[11.15]]. The 3-phase power balance problem asks for a way to partition a set of n positive integers into three sets &lt;math&gt;A&lt;/math&gt;, &lt;math&gt;B&lt;/math&gt;, or &lt;math&gt;C&lt;/math&gt; such that &lt;math&gt;\sum_{i} a_i = \sum_{i} b_i = \sum_{i} c_i&lt;/math&gt;. Prove that this problem is NP-hard using a reduction from integer partition or subset sum (see Section 10.5 (page 329)).
[[11.15|Solution]]


:11.16. Show that the following problem is NP-complete:
:* ''Problem:'' Dense subgraph
:* ''Input:'' A graph &lt;math&gt;G&lt;/math&gt;, and integers &lt;math&gt;k&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;G&lt;/math&gt; contain a subgraph with exactly &lt;math&gt;k&lt;/math&gt; vertices and at least &lt;math&gt;y&lt;/math&gt; edges?


:[[11.17]]. Show that the following problem is NP-complete:
:* ''Problem:'' Clique, no-clique
:* ''Input:'' An undirected graph &lt;math&gt;G=(V,E)&lt;/math&gt; and an integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;G&lt;/math&gt; contain both a clique of size &lt;math&gt;k&lt;/math&gt; and an independent set of size &lt;math&gt;k&lt;/math&gt;.
[[11.17|Solution]]


:11.18. n ''Eulerian cycle'' is a tour that visits every edge in a graph exactly once. An ''Eulerian subgraph'' is a subset of the edges and vertices of a graph that has an Eulerian cycle. Prove that the problem of finding the number of edges in the largest Eulerian subgraph of a graph is NP-hard. (Hint: the Hamiltonian circuit problem is NP-hard even if each vertex in the graph is incident upon exactly three edges.)


:[[11.19]]. Show that the following problem is NP-hard:
:*''Problem:'' Maximum Common Subgraph
:*''Input:'' Two graphs &lt;math&gt;G_1 = (V_1, E_1)&lt;/math&gt; and &lt;math&gt;G_2 = (V_2, E_2)&lt;/math&gt;, and a budget &lt;math&gt;b&lt;/math&gt;.
:*Output: Two sets of nodes &lt;math&gt;S_1 \subseteq V_1&lt;/math&gt; and &lt;math&gt;S_2 \subseteq V_2&lt;/math&gt; whose deletion leaves at least &lt;math&gt;b&lt;/math&gt; nodes in each graph, and makes the two graphs identical.
[[11.19|Solution]]


:11.20. A ''strongly independent'' set is a subset of vertices &lt;math&gt;S&lt;/math&gt; in a graph &lt;math&gt;G&lt;/math&gt; such that for any two vertices in &lt;math&gt;S&lt;/math&gt;, there is no path of length two in &lt;math&gt;G&lt;/math&gt;. Prove that strongly independent set is NP-hard.


:[[11.21]]. A ''kite'' is a graph on an even number of vertices, say &lt;math&gt;2n&lt;/math&gt;, in which &lt;math&gt;n&lt;/math&gt; of the vertices form a clique and the remaining &lt;math&gt;n&lt;/math&gt; vertices are connected in a tail that consists of a path joined to one of the vertices of the clique. Given a graph and a goal g, the ''max kite'' problem asks for a subgraph that is a kite and contains &lt;math&gt;2g&lt;/math&gt; nodes. Prove that ''max kite'' is NP-hard.
[[11.21|Solution]]

===Creative Reductions===

:11.22. Prove that the following problem is NP-complete:
:* ''Problem:'' Hitting Set
:* ''Input:'' A collection &lt;math&gt;C&lt;/math&gt; of subsets of a set &lt;math&gt;S&lt;/math&gt;, positive integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;S&lt;/math&gt; contain a subset &lt;math&gt;S'&lt;/math&gt; such that &lt;math&gt;|S'| \leq k&lt;/math&gt; and each subset in &lt;math&gt;C&lt;/math&gt; contains at least one element from &lt;math&gt;S'&lt;/math&gt;?


:[[11.23]]. Prove that the following problem is NP-complete:
:* ''Problem:'' Knapsack
:* ''Input:'' A set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; items, such that the &lt;math&gt;i&lt;/math&gt;th item has value &lt;math&gt;v_i&lt;/math&gt; and weight &lt;math&gt;w_i&lt;/math&gt;.  Two positive integers: weight limit &lt;math&gt;W&lt;/math&gt; and value requirement &lt;math&gt;V&lt;/math&gt;.
:* ''Output:'' Does there exist a subset &lt;math&gt;S' \in S&lt;/math&gt; such that &lt;math&gt;\sum_{i \in S'} w_i \leq W&lt;/math&gt; and &lt;math&gt;\sum_{i \in S'} v_i \geq V&lt;/math&gt;? 
:(Hint: start from integer partition.)
[[11.23|Solution]]


:11.24. Prove that the following problem is NP-complete:
:* ''Problem:'' Hamiltonian Path
:* ''Input:'' A graph &lt;math&gt;G&lt;/math&gt;, and vertices &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;G&lt;/math&gt; contain a path which starts from &lt;math&gt;s&lt;/math&gt;, ends at &lt;math&gt;t&lt;/math&gt;, and visits all vertices without visiting any vertex more than once? (Hint: start from Hamiltonian cycle.)


:[[11.25]]. Prove that the following problem is NP-complete:
:* ''Problem:'' Longest Path
:* ''Input:'' A graph &lt;math&gt;G&lt;/math&gt; and positive integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;G&lt;/math&gt; contain a path that visits at least &lt;math&gt;k&lt;/math&gt; different vertices without visiting any vertex more than once?
[[11.25|Solution]]


:11.26. Prove that the following problem is NP-complete:
:* ''Problem:'' Dominating Set
:* ''Input:'' A graph &lt;math&gt;G=(V,E)&lt;/math&gt; and positive integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Is there a subset &lt;math&gt;V' \in V&lt;/math&gt; such that &lt;math&gt;|V'|\leq k&lt;/math&gt; where for each vertex &lt;math&gt;x \in V&lt;/math&gt; either &lt;math&gt;x \in V'&lt;/math&gt; or there exists an edge &lt;math&gt;(x,y)&lt;/math&gt;, where &lt;math&gt;y \in V'&lt;/math&gt;.


:[[11.27]]. Prove that the vertex cover problem (does there exist a subset &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;k&lt;/math&gt; vertices in a graph &lt;math&gt;G&lt;/math&gt; such that every edge in &lt;math&gt;G&lt;/math&gt; is incident upon at least one vertex in &lt;math&gt;S&lt;/math&gt;?) remains NP-complete even when all the vertices in the graph are restricted to have even degrees.
[[11.27|Solution]]


:11.28. Prove that the following problem is NP-complete:
:* ''Problem:'' Set Packing
:* ''Input:'' A collection &lt;math&gt;C&lt;/math&gt; of subsets of a set &lt;math&gt;S&lt;/math&gt;, positive integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;S&lt;/math&gt; contain at least &lt;math&gt;k&lt;/math&gt; disjoint subsets (i.e., such that none of these subsets have any elements in common?)


:[[11.29]]. Prove that the following problem is NP-complete:
:* ''Problem:'' Feedback Vertex Set
:* ''Input:'' A directed graph &lt;math&gt;G=(V,A)&lt;/math&gt; and positive integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Is there a subset &lt;math&gt;V' \in V&lt;/math&gt; such that &lt;math&gt;|V'|\leq k&lt;/math&gt;, such that deleting the vertices of &lt;math&gt;V'&lt;/math&gt; from &lt;math&gt;G&lt;/math&gt; leaves a DAG?
[[11.29|Solution]]


:11.30. Give a reduction from Sudoku to the vertex coloring problem in graphs. Specifically, describe how to take any partially filled Sudoku board and construct a graph that can be colored with nine colors iff the Sudoku board is solvable.

===Algorithms for Special Cases===

:[[11.31]]. A Hamiltonian path &lt;math&gt;P&lt;/math&gt; is a path that visits each vertex exactly once. The problem of testing whether a graph &lt;math&gt;G&lt;/math&gt; contains a Hamiltonian path is NP-complete. There does not have to be an edge in &lt;math&gt;G&lt;/math&gt; from the ending vertex to the starting vertex of &lt;math&gt;P&lt;/math&gt;, unlike in the Hamiltonian cycle problem. Give an &lt;math&gt;O(n+m)&lt;/math&gt;-time algorithm to test whether a directed acyclic graph &lt;math&gt;G&lt;/math&gt; (a DAG) contains a Hamiltonian path. (Hint: think about topological sorting and DFS.)
[[11.31|Solution]]


:11.32. Consider the ''k''-clique problem, which is the general clique problem restricted to graphs in which every vertex has degree at most &lt;math&gt;k&lt;/math&gt;. Prove that ''k''-clique has an efficient algorithm for any given &lt;math&gt;k&lt;/math&gt;, meaning that &lt;math&gt;k&lt;/math&gt; is a constant.


:[[11.33]]. The &lt;math&gt;2&lt;/math&gt;-SAT problem is, given a Boolean formula in 2-conjunctive normal form (CNF), to decide whether the formula is satisfiable. &lt;math&gt;2&lt;/math&gt;-SAT is like &lt;math&gt;3&lt;/math&gt;-SAT, except that each clause can have only two literals. For example, the following formula is in &lt;math&gt;2&lt;/math&gt;-CNF: &lt;math&gt; (x_1 \or x_2) \and (\bar{x}_2 \or x_3) \and (x_1 \or \bar{x}_3) &lt;/math&gt; 
:Give a polynomial-time algorithm to solve &lt;math&gt;2&lt;/math&gt;-SAT.
[[11.33|Solution]]


:11.34, Show that the following problems are in NP:
#Does graph &lt;math&gt;G&lt;/math&gt; have a simple path (i.e., with no vertex repeated) of length &lt;math&gt;k&lt;/math&gt;? \#Is integer &lt;math&gt;n&lt;/math&gt; composite (i.e., not prime)? 
#Does graph &lt;math&gt;G&lt;/math&gt; have a vertex cover of size &lt;math&gt;k&lt;/math&gt;?


:[[11.35]]. Until 2002, it was an open question whether the decision problem ''Is integer &lt;math&gt;n&lt;/math&gt; a composite number, in other words, not prime?'' can be computed in time polynomial in the size of its input. Why doesn't the following algorithm suffice to prove it is in P, since it runs in &lt;math&gt;O(n)&lt;/math&gt; time?
   PrimalityTesting(&lt;math&gt;n&lt;/math&gt;)
      composite := &lt;math&gt;false&lt;/math&gt;
      for i := 2 to &lt;math&gt;n-1&lt;/math&gt; do
         if &lt;math&gt;(n\,\bmod\,i) = 0&lt;/math&gt; then
            composite := &lt;math&gt;true&lt;/math&gt;
[[11.35|Solution]]


Back to [[Chapter List]]</text>
      <sha1>2ff1mub2dmyhfq1p9ektvou6i4mk5ok</sha1>
    </revision>
    <revision>
      <id>457</id>
      <parentid>204</parentid>
      <timestamp>2020-10-01T18:10:47Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <minor/>
      <comment>Protected "[[Chapter 11]]" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="13605">=NP-Completeness=

===Transformations and Satisfiability===

:[[11.1]]. Give the 3-SAT formula that results from applying the reduction of SAT to 3-SAT for the formula: 
:::&lt;math&gt; (x\or y \or \overline z \or w \or u \or \overline v) \and (\overline x \or \overline 
y \or z \or \overline w \or u \or v) \and (x \or \overline y \or \overline z \or w \or u \or \overline v)\and (x \or \overline y) &lt;/math&gt;
[[11.1|Solution]]


:11.2. Draw the graph that results from the reduction of 3-SAT to vertex cover for the expression 
:::&lt;math&gt;(x \or \overline y \or z) \and (\overline x \or y \or \overline z) \and(\overline x \or y \or z) \and (x \or \overline y \or \overline x) &lt;/math&gt;


:[[11.3]]. Prove that 4-SAT is NP-hard.
[[11.3|Solution]]


:11.4. ''Stingy'' SAT is the following problem: given a set of clauses (each a disjunction of literals) and an integer &lt;math&gt;k&lt;/math&gt;, find a satisfying assignment in which at most &lt;math&gt;k&lt;/math&gt; variables are true, if such an assignment exists. Prove that stingy SAT is NP-hard.


:[[11.5]]. The ''Double SAT'' problem asks whether a given satisfiability problem has '''at least two different satisfying assignments'''. For example, the problem &lt;math&gt;{{v1, v2}, {v_1, v_2}, {v_1, v_2}}&lt;/math&gt; is satisfiable, but has only one solution &lt;math&gt;(v_1 =F, v_2 = T)&lt;/math&gt;. In contrast, &lt;math&gt;{{v_1, v_2}, {v_1, v_2}}&lt;/math&gt; has exactly two solutions. Show that Double-SAT is NP-hard.
[[11.5|Solution]]


:11.6. Suppose we are given a subroutine that can solve the traveling salesman decision problem on page 357 in (say) linear time. Give an efficient algorithm to find the actual TSP tour by making a polynomial number of calls to this subroutine.


:[[11.7]]. Implement a SAT to 3-SAT reduction that translates satisfiability instances into equivalent 3-SAT instances.
[[11.7|Solution]]


:11.8. Design and implement a backtracking algorithm to test whether a set of clause sets is satisfiable. What criteria can you use to prune this search?


:[[11.9]]. Implement the vertex cover to satisfiability reduction, and run the resulting clauses through a satisfiability solver code. Does this seem like a practical way to compute things?
[[11.9|Solution]]

===Basic Reductions===

:11.10. An instance of the ''set cover'' problem consists of a set &lt;math&gt;X&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; elements, a family &lt;math&gt;F&lt;/math&gt; of subsets of &lt;math&gt;X&lt;/math&gt;, and an integer &lt;math&gt;k&lt;/math&gt;. The question is, does there exist &lt;math&gt;k&lt;/math&gt; subsets from &lt;math&gt;F&lt;/math&gt; whose union is &lt;math&gt;X&lt;/math&gt;? For example, if &lt;math&gt;X = \{1,2,3,4\}&lt;/math&gt; and &lt;math&gt;F = \{ \{1,2\}, \{2,3\}, \{4\}, \{2,4\} \}&lt;/math&gt;, there does not exist a solution for &lt;math&gt;k=2&lt;/math&gt;, but there does for &lt;math&gt;k=3&lt;/math&gt; (for example, &lt;math&gt; \{1,2\}, \{2,3\}, \{4\}&lt;/math&gt;). Prove that set cover is NP-complete with a reduction from vertex cover.


:[[11.11]]. The ''baseball card collector problem'' is as follows. Given packets &lt;math&gt;P_1, \ldots, P_m&lt;/math&gt;, each of which contains a subset of this year's baseball cards, is it possible to collect all the year's cards by buying &lt;math&gt;\leq k&lt;/math&gt; packets? For example, if the players are &lt;math&gt; \{Aaron, Mays, Ruth, Steven \} &lt;/math&gt; and the packets are
:::&lt;math&gt; \{ \{Aaron,Mays\}, \{Mays,Ruth\}, \{Steven\}, \{Mays,Steven\} \}, &lt;/math&gt; 
:there does not exist a solution for &lt;math&gt;k=2&lt;/math&gt;, but there does for &lt;math&gt;k=3&lt;/math&gt;, such as 
:::&lt;math&gt; \{Aaron,Mays\}, \{Mays,Ruth\}, \{Steven\} &lt;/math&gt; 
:Prove that the baseball card collector problem is NP hard using a reduction from vertex cover.
[[11.11|Solution]]


:11.12. The ''low-degree spanning tree problem'' is as follows. Given a graph &lt;math&gt;G&lt;/math&gt; and an integer &lt;math&gt;k&lt;/math&gt;, does &lt;math&gt;G&lt;/math&gt; contain a spanning tree such that all vertices in the tree have degree ''at most'' &lt;math&gt;k&lt;/math&gt; (obviously, only tree edges count towards the degree)? For example, in the following graph, there is no spanning tree such that all vertices have a degree less than three.
\fixedfigsize{pictures/lowdegree.png}{1.0in}
#Prove that the low-degree spanning tree problem is NP-hard with a reduction from Hamiltonian ''path''. 
#Now consider the ''high-degree spanning tree problem'', which is as follows. Given a graph &lt;math&gt;G&lt;/math&gt; and an integer &lt;math&gt;k&lt;/math&gt;, does &lt;math&gt;G&lt;/math&gt; contain a spanning tree whose highest degree vertex is ''at least'' &lt;math&gt;k&lt;/math&gt;? In the previous example, there exists a spanning tree with a highest degree of 8. Give an efficient algorithm to solve the high-degree spanning tree problem, and an analysis of its time complexity.


:[[11.13]].In the minimum element set cover problem, we seek a set cover &lt;math&gt;S \subseteq C&lt;/math&gt; of a universal set &lt;math&gt;U = {1, . . . , n}&lt;/math&gt; such that sum of the sizes of the subsets in &lt;math&gt;S&lt;/math&gt; is at most &lt;math&gt;k&lt;/math&gt;. 
::(a) Show that &lt;math&gt;C = {{1, 2, 3}, {1, 3, 4}, {2, 3, 4}, {3, 4, 5}}&lt;/math&gt; has a cover of size 6, but none of size 5 because of a repeated element. 
::(b) Prove that this problem is NP-hard. (Hint: set cover remains hard if all subsets are of the same size.)
[[11.13|Solution]]


:11.14. The ''half-Hamiltonian cycle problem'' is, given a graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices, determine whether &lt;math&gt;G&lt;/math&gt; has a simple cycle of length exactly &lt;math&gt;[n/2]&lt;/math&gt;, where the floor function rounds its input down to the nearest integer. Prove that this problem is NP-hard.


:[[11.15]]. The 3-phase power balance problem asks for a way to partition a set of n positive integers into three sets &lt;math&gt;A&lt;/math&gt;, &lt;math&gt;B&lt;/math&gt;, or &lt;math&gt;C&lt;/math&gt; such that &lt;math&gt;\sum_{i} a_i = \sum_{i} b_i = \sum_{i} c_i&lt;/math&gt;. Prove that this problem is NP-hard using a reduction from integer partition or subset sum (see Section 10.5 (page 329)).
[[11.15|Solution]]


:11.16. Show that the following problem is NP-complete:
:* ''Problem:'' Dense subgraph
:* ''Input:'' A graph &lt;math&gt;G&lt;/math&gt;, and integers &lt;math&gt;k&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;G&lt;/math&gt; contain a subgraph with exactly &lt;math&gt;k&lt;/math&gt; vertices and at least &lt;math&gt;y&lt;/math&gt; edges?


:[[11.17]]. Show that the following problem is NP-complete:
:* ''Problem:'' Clique, no-clique
:* ''Input:'' An undirected graph &lt;math&gt;G=(V,E)&lt;/math&gt; and an integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;G&lt;/math&gt; contain both a clique of size &lt;math&gt;k&lt;/math&gt; and an independent set of size &lt;math&gt;k&lt;/math&gt;.
[[11.17|Solution]]


:11.18. n ''Eulerian cycle'' is a tour that visits every edge in a graph exactly once. An ''Eulerian subgraph'' is a subset of the edges and vertices of a graph that has an Eulerian cycle. Prove that the problem of finding the number of edges in the largest Eulerian subgraph of a graph is NP-hard. (Hint: the Hamiltonian circuit problem is NP-hard even if each vertex in the graph is incident upon exactly three edges.)


:[[11.19]]. Show that the following problem is NP-hard:
:*''Problem:'' Maximum Common Subgraph
:*''Input:'' Two graphs &lt;math&gt;G_1 = (V_1, E_1)&lt;/math&gt; and &lt;math&gt;G_2 = (V_2, E_2)&lt;/math&gt;, and a budget &lt;math&gt;b&lt;/math&gt;.
:*Output: Two sets of nodes &lt;math&gt;S_1 \subseteq V_1&lt;/math&gt; and &lt;math&gt;S_2 \subseteq V_2&lt;/math&gt; whose deletion leaves at least &lt;math&gt;b&lt;/math&gt; nodes in each graph, and makes the two graphs identical.
[[11.19|Solution]]


:11.20. A ''strongly independent'' set is a subset of vertices &lt;math&gt;S&lt;/math&gt; in a graph &lt;math&gt;G&lt;/math&gt; such that for any two vertices in &lt;math&gt;S&lt;/math&gt;, there is no path of length two in &lt;math&gt;G&lt;/math&gt;. Prove that strongly independent set is NP-hard.


:[[11.21]]. A ''kite'' is a graph on an even number of vertices, say &lt;math&gt;2n&lt;/math&gt;, in which &lt;math&gt;n&lt;/math&gt; of the vertices form a clique and the remaining &lt;math&gt;n&lt;/math&gt; vertices are connected in a tail that consists of a path joined to one of the vertices of the clique. Given a graph and a goal g, the ''max kite'' problem asks for a subgraph that is a kite and contains &lt;math&gt;2g&lt;/math&gt; nodes. Prove that ''max kite'' is NP-hard.
[[11.21|Solution]]

===Creative Reductions===

:11.22. Prove that the following problem is NP-complete:
:* ''Problem:'' Hitting Set
:* ''Input:'' A collection &lt;math&gt;C&lt;/math&gt; of subsets of a set &lt;math&gt;S&lt;/math&gt;, positive integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;S&lt;/math&gt; contain a subset &lt;math&gt;S'&lt;/math&gt; such that &lt;math&gt;|S'| \leq k&lt;/math&gt; and each subset in &lt;math&gt;C&lt;/math&gt; contains at least one element from &lt;math&gt;S'&lt;/math&gt;?


:[[11.23]]. Prove that the following problem is NP-complete:
:* ''Problem:'' Knapsack
:* ''Input:'' A set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; items, such that the &lt;math&gt;i&lt;/math&gt;th item has value &lt;math&gt;v_i&lt;/math&gt; and weight &lt;math&gt;w_i&lt;/math&gt;.  Two positive integers: weight limit &lt;math&gt;W&lt;/math&gt; and value requirement &lt;math&gt;V&lt;/math&gt;.
:* ''Output:'' Does there exist a subset &lt;math&gt;S' \in S&lt;/math&gt; such that &lt;math&gt;\sum_{i \in S'} w_i \leq W&lt;/math&gt; and &lt;math&gt;\sum_{i \in S'} v_i \geq V&lt;/math&gt;? 
:(Hint: start from integer partition.)
[[11.23|Solution]]


:11.24. Prove that the following problem is NP-complete:
:* ''Problem:'' Hamiltonian Path
:* ''Input:'' A graph &lt;math&gt;G&lt;/math&gt;, and vertices &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;G&lt;/math&gt; contain a path which starts from &lt;math&gt;s&lt;/math&gt;, ends at &lt;math&gt;t&lt;/math&gt;, and visits all vertices without visiting any vertex more than once? (Hint: start from Hamiltonian cycle.)


:[[11.25]]. Prove that the following problem is NP-complete:
:* ''Problem:'' Longest Path
:* ''Input:'' A graph &lt;math&gt;G&lt;/math&gt; and positive integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;G&lt;/math&gt; contain a path that visits at least &lt;math&gt;k&lt;/math&gt; different vertices without visiting any vertex more than once?
[[11.25|Solution]]


:11.26. Prove that the following problem is NP-complete:
:* ''Problem:'' Dominating Set
:* ''Input:'' A graph &lt;math&gt;G=(V,E)&lt;/math&gt; and positive integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Is there a subset &lt;math&gt;V' \in V&lt;/math&gt; such that &lt;math&gt;|V'|\leq k&lt;/math&gt; where for each vertex &lt;math&gt;x \in V&lt;/math&gt; either &lt;math&gt;x \in V'&lt;/math&gt; or there exists an edge &lt;math&gt;(x,y)&lt;/math&gt;, where &lt;math&gt;y \in V'&lt;/math&gt;.


:[[11.27]]. Prove that the vertex cover problem (does there exist a subset &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;k&lt;/math&gt; vertices in a graph &lt;math&gt;G&lt;/math&gt; such that every edge in &lt;math&gt;G&lt;/math&gt; is incident upon at least one vertex in &lt;math&gt;S&lt;/math&gt;?) remains NP-complete even when all the vertices in the graph are restricted to have even degrees.
[[11.27|Solution]]


:11.28. Prove that the following problem is NP-complete:
:* ''Problem:'' Set Packing
:* ''Input:'' A collection &lt;math&gt;C&lt;/math&gt; of subsets of a set &lt;math&gt;S&lt;/math&gt;, positive integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Does &lt;math&gt;S&lt;/math&gt; contain at least &lt;math&gt;k&lt;/math&gt; disjoint subsets (i.e., such that none of these subsets have any elements in common?)


:[[11.29]]. Prove that the following problem is NP-complete:
:* ''Problem:'' Feedback Vertex Set
:* ''Input:'' A directed graph &lt;math&gt;G=(V,A)&lt;/math&gt; and positive integer &lt;math&gt;k&lt;/math&gt;.
:* ''Output:'' Is there a subset &lt;math&gt;V' \in V&lt;/math&gt; such that &lt;math&gt;|V'|\leq k&lt;/math&gt;, such that deleting the vertices of &lt;math&gt;V'&lt;/math&gt; from &lt;math&gt;G&lt;/math&gt; leaves a DAG?
[[11.29|Solution]]


:11.30. Give a reduction from Sudoku to the vertex coloring problem in graphs. Specifically, describe how to take any partially filled Sudoku board and construct a graph that can be colored with nine colors iff the Sudoku board is solvable.

===Algorithms for Special Cases===

:[[11.31]]. A Hamiltonian path &lt;math&gt;P&lt;/math&gt; is a path that visits each vertex exactly once. The problem of testing whether a graph &lt;math&gt;G&lt;/math&gt; contains a Hamiltonian path is NP-complete. There does not have to be an edge in &lt;math&gt;G&lt;/math&gt; from the ending vertex to the starting vertex of &lt;math&gt;P&lt;/math&gt;, unlike in the Hamiltonian cycle problem. Give an &lt;math&gt;O(n+m)&lt;/math&gt;-time algorithm to test whether a directed acyclic graph &lt;math&gt;G&lt;/math&gt; (a DAG) contains a Hamiltonian path. (Hint: think about topological sorting and DFS.)
[[11.31|Solution]]


:11.32. Consider the ''k''-clique problem, which is the general clique problem restricted to graphs in which every vertex has degree at most &lt;math&gt;k&lt;/math&gt;. Prove that ''k''-clique has an efficient algorithm for any given &lt;math&gt;k&lt;/math&gt;, meaning that &lt;math&gt;k&lt;/math&gt; is a constant.


:[[11.33]]. The &lt;math&gt;2&lt;/math&gt;-SAT problem is, given a Boolean formula in 2-conjunctive normal form (CNF), to decide whether the formula is satisfiable. &lt;math&gt;2&lt;/math&gt;-SAT is like &lt;math&gt;3&lt;/math&gt;-SAT, except that each clause can have only two literals. For example, the following formula is in &lt;math&gt;2&lt;/math&gt;-CNF: &lt;math&gt; (x_1 \or x_2) \and (\bar{x}_2 \or x_3) \and (x_1 \or \bar{x}_3) &lt;/math&gt; 
:Give a polynomial-time algorithm to solve &lt;math&gt;2&lt;/math&gt;-SAT.
[[11.33|Solution]]


:11.34, Show that the following problems are in NP:
#Does graph &lt;math&gt;G&lt;/math&gt; have a simple path (i.e., with no vertex repeated) of length &lt;math&gt;k&lt;/math&gt;? \#Is integer &lt;math&gt;n&lt;/math&gt; composite (i.e., not prime)? 
#Does graph &lt;math&gt;G&lt;/math&gt; have a vertex cover of size &lt;math&gt;k&lt;/math&gt;?


:[[11.35]]. Until 2002, it was an open question whether the decision problem ''Is integer &lt;math&gt;n&lt;/math&gt; a composite number, in other words, not prime?'' can be computed in time polynomial in the size of its input. Why doesn't the following algorithm suffice to prove it is in P, since it runs in &lt;math&gt;O(n)&lt;/math&gt; time?
   PrimalityTesting(&lt;math&gt;n&lt;/math&gt;)
      composite := &lt;math&gt;false&lt;/math&gt;
      for i := 2 to &lt;math&gt;n-1&lt;/math&gt; do
         if &lt;math&gt;(n\,\bmod\,i) = 0&lt;/math&gt; then
            composite := &lt;math&gt;true&lt;/math&gt;
[[11.35|Solution]]


Back to [[Chapter List]]</text>
      <sha1>2ff1mub2dmyhfq1p9ektvou6i4mk5ok</sha1>
    </revision>
  </page>
  <page>
    <title>Chapter 12</title>
    <ns>0</ns>
    <id>15</id>
    <revision>
      <id>24</id>
      <timestamp>2020-08-23T19:36:14Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Problems   Back to [[Chapter List]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="35">Problems


Back to [[Chapter List]]</text>
      <sha1>95722ndl4ewzic1ak6z8g4auy0tqhc6</sha1>
    </revision>
    <revision>
      <id>122</id>
      <parentid>24</parentid>
      <timestamp>2020-09-07T19:48:34Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="420">=Dealing with Hard Problems=\

===Special Cases of Hard Problems===

:[[12.1]]


:12.2


:[[12.3]]


===Approximation Algorithms===

:12.4


:[[12.5]]


:12.6


:[[12.7]]


:12.8


:[[12.9]]


:12.10


:[[12.11]]


===Combinatorial Optimization===


:12.12


:[[12.13]]


:12.14


:[[12.15]]


:12.16


:[[12.17]]


:12.18


==="Quantum" Computing===

:[[12.19]]


:12.20


:[[12.21]]


:12.22


Back to [[Chapter List]]</text>
      <sha1>p2doklimbfxhzjxh8ng0mw5j88i3d8k</sha1>
    </revision>
    <revision>
      <id>163</id>
      <parentid>122</parentid>
      <timestamp>2020-09-10T20:30:41Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Special Cases of Hard Problems */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="2416">=Dealing with Hard Problems=\

===Special Cases of Hard Problems===

:[[12.1]]. Dominos are tiles represented by integer pairs &lt;math&gt;(x_i, y_i)&lt;/math&gt;, where each of the values &lt;math&gt;x_i&lt;/math&gt; and &lt;math&gt;y_i&lt;/math&gt; are integers between 1 and &lt;math&gt;n&lt;/math&gt;. Let &lt;math&gt;S&lt;/math&gt; be a sequence of m integer pairs &lt;math&gt;[(x_1, y_1),(x_2, y_2), ...,(x_m, y_m)]&lt;/math&gt;. The goal of the game is to create long chains &lt;math&gt;[(x_{i1}, y_{i1}),(x_{i2}, y_{i2}), ...,(x_{it}, y_{it})]&lt;/math&gt; such that &lt;math&gt;y_{ij} = x_{i(j+1)}&lt;/math&gt;. Dominos can be flipped, so &lt;math&gt;(x_i, y_i)&lt;/math&gt; equivalent to &lt;math&gt;(y_i, x_i)&lt;/math&gt;. For &lt;math&gt;S = [(1, 3),(4, 2),(3, 5),(2, 3),(3, 8)]&lt;/math&gt;, the longest domino sequences include &lt;math&gt;[(4, 2),(2, 3),(3, 8)]&lt;/math&gt; and &lt;math&gt;[(1, 3),(3, 2),(2, 4)]&lt;/math&gt;.
::(a) Prove that finding the longest domino chain is NP-complete.
::(b) Give an efficient algorithm to find the longest domino chain where the numbers increase along the chain. For S above, the longest such chains are &lt;math&gt;[(1, 3),(3, 5)]&lt;/math&gt; and &lt;math&gt;[(2, 3),(3, 5)]&lt;/math&gt;.
[[12.1|Solution]]


:12.2. Let &lt;math&gt;G = (V, E)&lt;/math&gt; be a graph and &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt; be two distinct vertices of &lt;math&gt;G&lt;/math&gt;. Each vertex &lt;math&gt;v&lt;/math&gt; contains a given number of tokens &lt;math&gt;t(v)&lt;/math&gt; that you can collect if you visit &lt;math&gt;v&lt;/math&gt;.
::(a) Prove that it is NP-complete to find the path from &lt;math&gt;x&lt;/math&gt; to &lt;math&gt;y&lt;/math&gt; where you can collect the greatest possible number of tokens.
::(b) Give an efficient algorithm if &lt;math&gt;G&lt;/math&gt; is a directed acyclic graph (DAG).


:[[12.3]]. The ''Hamiltonian completion problem'' takes a given graph &lt;math&gt;G&lt;/math&gt; and seeks an algorithm to add the smallest number of edges to &lt;math&gt;G&lt;/math&gt; so that it contains a Hamiltonian cycle. This problem is NP-complete for general graphs; however, it has an efficient algorithm if &lt;math&gt;G&lt;/math&gt; is a tree. Give an efficient and provably correct algorithm to add the minimum number of possible edges to tree &lt;math&gt;T&lt;/math&gt; so that &lt;math&gt;T&lt;/math&gt; plus these edges is Hamiltonian.
[[12.3|Solution]]

===Approximation Algorithms===

:12.4


:[[12.5]]


:12.6


:[[12.7]]


:12.8


:[[12.9]]


:12.10


:[[12.11]]


===Combinatorial Optimization===


:12.12


:[[12.13]]


:12.14


:[[12.15]]


:12.16


:[[12.17]]


:12.18


==="Quantum" Computing===

:[[12.19]]


:12.20


:[[12.21]]


:12.22


Back to [[Chapter List]]</text>
      <sha1>ji6dnj2gwan2gxo8ksja4j5olbes0za</sha1>
    </revision>
    <revision>
      <id>164</id>
      <parentid>163</parentid>
      <timestamp>2020-09-10T20:45:17Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Approximation Algorithms */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="4999">=Dealing with Hard Problems=\

===Special Cases of Hard Problems===

:[[12.1]]. Dominos are tiles represented by integer pairs &lt;math&gt;(x_i, y_i)&lt;/math&gt;, where each of the values &lt;math&gt;x_i&lt;/math&gt; and &lt;math&gt;y_i&lt;/math&gt; are integers between 1 and &lt;math&gt;n&lt;/math&gt;. Let &lt;math&gt;S&lt;/math&gt; be a sequence of m integer pairs &lt;math&gt;[(x_1, y_1),(x_2, y_2), ...,(x_m, y_m)]&lt;/math&gt;. The goal of the game is to create long chains &lt;math&gt;[(x_{i1}, y_{i1}),(x_{i2}, y_{i2}), ...,(x_{it}, y_{it})]&lt;/math&gt; such that &lt;math&gt;y_{ij} = x_{i(j+1)}&lt;/math&gt;. Dominos can be flipped, so &lt;math&gt;(x_i, y_i)&lt;/math&gt; equivalent to &lt;math&gt;(y_i, x_i)&lt;/math&gt;. For &lt;math&gt;S = [(1, 3),(4, 2),(3, 5),(2, 3),(3, 8)]&lt;/math&gt;, the longest domino sequences include &lt;math&gt;[(4, 2),(2, 3),(3, 8)]&lt;/math&gt; and &lt;math&gt;[(1, 3),(3, 2),(2, 4)]&lt;/math&gt;.
::(a) Prove that finding the longest domino chain is NP-complete.
::(b) Give an efficient algorithm to find the longest domino chain where the numbers increase along the chain. For S above, the longest such chains are &lt;math&gt;[(1, 3),(3, 5)]&lt;/math&gt; and &lt;math&gt;[(2, 3),(3, 5)]&lt;/math&gt;.
[[12.1|Solution]]


:12.2. Let &lt;math&gt;G = (V, E)&lt;/math&gt; be a graph and &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt; be two distinct vertices of &lt;math&gt;G&lt;/math&gt;. Each vertex &lt;math&gt;v&lt;/math&gt; contains a given number of tokens &lt;math&gt;t(v)&lt;/math&gt; that you can collect if you visit &lt;math&gt;v&lt;/math&gt;.
::(a) Prove that it is NP-complete to find the path from &lt;math&gt;x&lt;/math&gt; to &lt;math&gt;y&lt;/math&gt; where you can collect the greatest possible number of tokens.
::(b) Give an efficient algorithm if &lt;math&gt;G&lt;/math&gt; is a directed acyclic graph (DAG).


:[[12.3]]. The ''Hamiltonian completion problem'' takes a given graph &lt;math&gt;G&lt;/math&gt; and seeks an algorithm to add the smallest number of edges to &lt;math&gt;G&lt;/math&gt; so that it contains a Hamiltonian cycle. This problem is NP-complete for general graphs; however, it has an efficient algorithm if &lt;math&gt;G&lt;/math&gt; is a tree. Give an efficient and provably correct algorithm to add the minimum number of possible edges to tree &lt;math&gt;T&lt;/math&gt; so that &lt;math&gt;T&lt;/math&gt; plus these edges is Hamiltonian.
[[12.3|Solution]]

===Approximation Algorithms===

:12.4. In the ''maximum satisfiability problem'', we seek a truth assignment that satisfies as many clauses as possible. Give an heuristic that always satisfies at least half as many clauses as the optimal solution.


:[[12.5]]. Consider the following heuristic for vertex cover. Construct a DFS tree of the graph, and delete all the leaves from this tree. What remains must be a vertex cover of the graph. Prove that the size of this cover is at most twice as large as optimal.
[[12.5|Solution]]


:12.6. The ''maximum cut problem'' for a graph &lt;math&gt;G = (V, E)&lt;/math&gt; seeks to partition the vertices &lt;math&gt;V&lt;/math&gt; into disjoint sets &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; so as to maximize the number of edges &lt;math&gt;(a, b) \in E&lt;/math&gt; such that &lt;math&gt;a \in A&lt;/math&gt; and &lt;math&gt;b \in B&lt;/math&gt;. Consider the following heuristic for maximum cut. First assign &lt;math&gt;v_1&lt;/math&gt; to &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;v_2&lt;/math&gt; to &lt;math&gt;B&lt;/math&gt;. For each remaining vertex, assign it to the side that adds the most edges to the cut. Prove that this cut is at least half as large as the optimal cut.


:[[12.7]]. [5] In the ''bin-packing problem'', we are given n objects with weights &lt;math&gt;w_1, w_2, ..., w_n&lt;/math&gt;, respectively. Our goal is to find the smallest number of bins that will hold the &lt;math&gt;n&lt;/math&gt; objects, where each bin has a capacity of at most one kilogram.
:The ''first-fit heuristic'' considers the objects in the order in which they are given. For each object, place it into the first bin that has room for it. If no such bin exists, start a new bin. Prove that this heuristic uses at most twice as many bins as the optimal solution.
[[12.7|Solution]]


:12.8. For the first-fit heuristic described just above, give an example where the packing it finds uses at least 5/3 times as many bins as optimal.


:[[12.9]]. Given an undirected graph &lt;math&gt;G = (V, E)&lt;/math&gt; in which each node has degree ≤ d, show how to efficiently find an independent set whose size is at least &lt;math&gt;1/(d + 1)&lt;/math&gt; times that of the largest independent set.
[[12.9|Solution]]


:12.10. A vertex coloring of graph &lt;math&gt;G = (V, E)&lt;/math&gt; is an assignment of colors to vertices of &lt;math&gt;V&lt;/math&gt; such that each edge &lt;math&gt;(x, y)&lt;/math&gt; implies that vertices &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt; are assigned different colors. Give an algorithm for vertex coloring &lt;math&gt;G&lt;/math&gt; using at most &lt;math&gt;\Delta + 1&lt;/math&gt; colors, where &lt;math&gt;\Delta&lt;/math&gt; is the maximum vertex degree of &lt;math&gt;G&lt;/math&gt;.


:[[12.11]]. Show that you can solve any given Sudoku puzzle by finding the minimum vertex coloring of a specific, appropriately constructed (9×9)+9 vertex graph.
[[12.11|Solution]]

===Combinatorial Optimization===


:12.12


:[[12.13]]


:12.14


:[[12.15]]


:12.16


:[[12.17]]


:12.18


==="Quantum" Computing===

:[[12.19]]


:12.20


:[[12.21]]


:12.22


Back to [[Chapter List]]</text>
      <sha1>k8ki96ol0bzdskdby8wq3a0vwk01uho</sha1>
    </revision>
    <revision>
      <id>165</id>
      <parentid>164</parentid>
      <timestamp>2020-09-10T20:57:33Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Combinatorial Optimization */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="5979">=Dealing with Hard Problems=\

===Special Cases of Hard Problems===

:[[12.1]]. Dominos are tiles represented by integer pairs &lt;math&gt;(x_i, y_i)&lt;/math&gt;, where each of the values &lt;math&gt;x_i&lt;/math&gt; and &lt;math&gt;y_i&lt;/math&gt; are integers between 1 and &lt;math&gt;n&lt;/math&gt;. Let &lt;math&gt;S&lt;/math&gt; be a sequence of m integer pairs &lt;math&gt;[(x_1, y_1),(x_2, y_2), ...,(x_m, y_m)]&lt;/math&gt;. The goal of the game is to create long chains &lt;math&gt;[(x_{i1}, y_{i1}),(x_{i2}, y_{i2}), ...,(x_{it}, y_{it})]&lt;/math&gt; such that &lt;math&gt;y_{ij} = x_{i(j+1)}&lt;/math&gt;. Dominos can be flipped, so &lt;math&gt;(x_i, y_i)&lt;/math&gt; equivalent to &lt;math&gt;(y_i, x_i)&lt;/math&gt;. For &lt;math&gt;S = [(1, 3),(4, 2),(3, 5),(2, 3),(3, 8)]&lt;/math&gt;, the longest domino sequences include &lt;math&gt;[(4, 2),(2, 3),(3, 8)]&lt;/math&gt; and &lt;math&gt;[(1, 3),(3, 2),(2, 4)]&lt;/math&gt;.
::(a) Prove that finding the longest domino chain is NP-complete.
::(b) Give an efficient algorithm to find the longest domino chain where the numbers increase along the chain. For S above, the longest such chains are &lt;math&gt;[(1, 3),(3, 5)]&lt;/math&gt; and &lt;math&gt;[(2, 3),(3, 5)]&lt;/math&gt;.
[[12.1|Solution]]


:12.2. Let &lt;math&gt;G = (V, E)&lt;/math&gt; be a graph and &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt; be two distinct vertices of &lt;math&gt;G&lt;/math&gt;. Each vertex &lt;math&gt;v&lt;/math&gt; contains a given number of tokens &lt;math&gt;t(v)&lt;/math&gt; that you can collect if you visit &lt;math&gt;v&lt;/math&gt;.
::(a) Prove that it is NP-complete to find the path from &lt;math&gt;x&lt;/math&gt; to &lt;math&gt;y&lt;/math&gt; where you can collect the greatest possible number of tokens.
::(b) Give an efficient algorithm if &lt;math&gt;G&lt;/math&gt; is a directed acyclic graph (DAG).


:[[12.3]]. The ''Hamiltonian completion problem'' takes a given graph &lt;math&gt;G&lt;/math&gt; and seeks an algorithm to add the smallest number of edges to &lt;math&gt;G&lt;/math&gt; so that it contains a Hamiltonian cycle. This problem is NP-complete for general graphs; however, it has an efficient algorithm if &lt;math&gt;G&lt;/math&gt; is a tree. Give an efficient and provably correct algorithm to add the minimum number of possible edges to tree &lt;math&gt;T&lt;/math&gt; so that &lt;math&gt;T&lt;/math&gt; plus these edges is Hamiltonian.
[[12.3|Solution]]

===Approximation Algorithms===

:12.4. In the ''maximum satisfiability problem'', we seek a truth assignment that satisfies as many clauses as possible. Give an heuristic that always satisfies at least half as many clauses as the optimal solution.


:[[12.5]]. Consider the following heuristic for vertex cover. Construct a DFS tree of the graph, and delete all the leaves from this tree. What remains must be a vertex cover of the graph. Prove that the size of this cover is at most twice as large as optimal.
[[12.5|Solution]]


:12.6. The ''maximum cut problem'' for a graph &lt;math&gt;G = (V, E)&lt;/math&gt; seeks to partition the vertices &lt;math&gt;V&lt;/math&gt; into disjoint sets &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; so as to maximize the number of edges &lt;math&gt;(a, b) \in E&lt;/math&gt; such that &lt;math&gt;a \in A&lt;/math&gt; and &lt;math&gt;b \in B&lt;/math&gt;. Consider the following heuristic for maximum cut. First assign &lt;math&gt;v_1&lt;/math&gt; to &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;v_2&lt;/math&gt; to &lt;math&gt;B&lt;/math&gt;. For each remaining vertex, assign it to the side that adds the most edges to the cut. Prove that this cut is at least half as large as the optimal cut.


:[[12.7]]. [5] In the ''bin-packing problem'', we are given n objects with weights &lt;math&gt;w_1, w_2, ..., w_n&lt;/math&gt;, respectively. Our goal is to find the smallest number of bins that will hold the &lt;math&gt;n&lt;/math&gt; objects, where each bin has a capacity of at most one kilogram.
:The ''first-fit heuristic'' considers the objects in the order in which they are given. For each object, place it into the first bin that has room for it. If no such bin exists, start a new bin. Prove that this heuristic uses at most twice as many bins as the optimal solution.
[[12.7|Solution]]


:12.8. For the first-fit heuristic described just above, give an example where the packing it finds uses at least 5/3 times as many bins as optimal.


:[[12.9]]. Given an undirected graph &lt;math&gt;G = (V, E)&lt;/math&gt; in which each node has degree ≤ d, show how to efficiently find an independent set whose size is at least &lt;math&gt;1/(d + 1)&lt;/math&gt; times that of the largest independent set.
[[12.9|Solution]]


:12.10. A vertex coloring of graph &lt;math&gt;G = (V, E)&lt;/math&gt; is an assignment of colors to vertices of &lt;math&gt;V&lt;/math&gt; such that each edge &lt;math&gt;(x, y)&lt;/math&gt; implies that vertices &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt; are assigned different colors. Give an algorithm for vertex coloring &lt;math&gt;G&lt;/math&gt; using at most &lt;math&gt;\Delta + 1&lt;/math&gt; colors, where &lt;math&gt;\Delta&lt;/math&gt; is the maximum vertex degree of &lt;math&gt;G&lt;/math&gt;.


:[[12.11]]. Show that you can solve any given Sudoku puzzle by finding the minimum vertex coloring of a specific, appropriately constructed (9×9)+9 vertex graph.
[[12.11|Solution]]

===Combinatorial Optimization===
For each of the problems below, design and implement a simulated annealing heuristic to get reasonable solutions. How well does your program perform in practice?


:12.12. Design and implement a heuristic for the bandwidth minimization problem discussed in Section 16.2 (page 470).


:[[12.13]]. Design and implement a heuristic for the maximum satisfiability problem discussed in Section 17.10 (page 537).
[[12.13|Solution]]


:12.14. Design and implement a heuristic for the maximum clique problem discussed in Section 19.1 (page 586).


:[[12.15]]. Design and implement a heuristic for the minimum vertex coloring problem discussed in Section 19.7 (page 604).
[[12.15|Solution]]


:12.16. Design and implement a heuristic for the minimum edge coloring problem discussed in Section 19.8 (page 608).


:[[12.17]]. Design and implement a heuristic for the minimum feedback vertex set problem discussed in Section 19.11 (page 618).
[[12.7|Solution]]


:12.18. Design and implement a heuristic for the set cover problem discussed in Section 21.1 (page 678).

==="Quantum" Computing===

:[[12.19]]


:12.20


:[[12.21]]


:12.22


Back to [[Chapter List]]</text>
      <sha1>i5u0dnk0weso4gme0fuanzipjjo83kw</sha1>
    </revision>
    <revision>
      <id>166</id>
      <parentid>165</parentid>
      <timestamp>2020-09-10T21:03:44Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* "Quantum" Computing */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="7056">=Dealing with Hard Problems=\

===Special Cases of Hard Problems===

:[[12.1]]. Dominos are tiles represented by integer pairs &lt;math&gt;(x_i, y_i)&lt;/math&gt;, where each of the values &lt;math&gt;x_i&lt;/math&gt; and &lt;math&gt;y_i&lt;/math&gt; are integers between 1 and &lt;math&gt;n&lt;/math&gt;. Let &lt;math&gt;S&lt;/math&gt; be a sequence of m integer pairs &lt;math&gt;[(x_1, y_1),(x_2, y_2), ...,(x_m, y_m)]&lt;/math&gt;. The goal of the game is to create long chains &lt;math&gt;[(x_{i1}, y_{i1}),(x_{i2}, y_{i2}), ...,(x_{it}, y_{it})]&lt;/math&gt; such that &lt;math&gt;y_{ij} = x_{i(j+1)}&lt;/math&gt;. Dominos can be flipped, so &lt;math&gt;(x_i, y_i)&lt;/math&gt; equivalent to &lt;math&gt;(y_i, x_i)&lt;/math&gt;. For &lt;math&gt;S = [(1, 3),(4, 2),(3, 5),(2, 3),(3, 8)]&lt;/math&gt;, the longest domino sequences include &lt;math&gt;[(4, 2),(2, 3),(3, 8)]&lt;/math&gt; and &lt;math&gt;[(1, 3),(3, 2),(2, 4)]&lt;/math&gt;.
::(a) Prove that finding the longest domino chain is NP-complete.
::(b) Give an efficient algorithm to find the longest domino chain where the numbers increase along the chain. For S above, the longest such chains are &lt;math&gt;[(1, 3),(3, 5)]&lt;/math&gt; and &lt;math&gt;[(2, 3),(3, 5)]&lt;/math&gt;.
[[12.1|Solution]]


:12.2. Let &lt;math&gt;G = (V, E)&lt;/math&gt; be a graph and &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt; be two distinct vertices of &lt;math&gt;G&lt;/math&gt;. Each vertex &lt;math&gt;v&lt;/math&gt; contains a given number of tokens &lt;math&gt;t(v)&lt;/math&gt; that you can collect if you visit &lt;math&gt;v&lt;/math&gt;.
::(a) Prove that it is NP-complete to find the path from &lt;math&gt;x&lt;/math&gt; to &lt;math&gt;y&lt;/math&gt; where you can collect the greatest possible number of tokens.
::(b) Give an efficient algorithm if &lt;math&gt;G&lt;/math&gt; is a directed acyclic graph (DAG).


:[[12.3]]. The ''Hamiltonian completion problem'' takes a given graph &lt;math&gt;G&lt;/math&gt; and seeks an algorithm to add the smallest number of edges to &lt;math&gt;G&lt;/math&gt; so that it contains a Hamiltonian cycle. This problem is NP-complete for general graphs; however, it has an efficient algorithm if &lt;math&gt;G&lt;/math&gt; is a tree. Give an efficient and provably correct algorithm to add the minimum number of possible edges to tree &lt;math&gt;T&lt;/math&gt; so that &lt;math&gt;T&lt;/math&gt; plus these edges is Hamiltonian.
[[12.3|Solution]]

===Approximation Algorithms===

:12.4. In the ''maximum satisfiability problem'', we seek a truth assignment that satisfies as many clauses as possible. Give an heuristic that always satisfies at least half as many clauses as the optimal solution.


:[[12.5]]. Consider the following heuristic for vertex cover. Construct a DFS tree of the graph, and delete all the leaves from this tree. What remains must be a vertex cover of the graph. Prove that the size of this cover is at most twice as large as optimal.
[[12.5|Solution]]


:12.6. The ''maximum cut problem'' for a graph &lt;math&gt;G = (V, E)&lt;/math&gt; seeks to partition the vertices &lt;math&gt;V&lt;/math&gt; into disjoint sets &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; so as to maximize the number of edges &lt;math&gt;(a, b) \in E&lt;/math&gt; such that &lt;math&gt;a \in A&lt;/math&gt; and &lt;math&gt;b \in B&lt;/math&gt;. Consider the following heuristic for maximum cut. First assign &lt;math&gt;v_1&lt;/math&gt; to &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;v_2&lt;/math&gt; to &lt;math&gt;B&lt;/math&gt;. For each remaining vertex, assign it to the side that adds the most edges to the cut. Prove that this cut is at least half as large as the optimal cut.


:[[12.7]]. [5] In the ''bin-packing problem'', we are given n objects with weights &lt;math&gt;w_1, w_2, ..., w_n&lt;/math&gt;, respectively. Our goal is to find the smallest number of bins that will hold the &lt;math&gt;n&lt;/math&gt; objects, where each bin has a capacity of at most one kilogram.
:The ''first-fit heuristic'' considers the objects in the order in which they are given. For each object, place it into the first bin that has room for it. If no such bin exists, start a new bin. Prove that this heuristic uses at most twice as many bins as the optimal solution.
[[12.7|Solution]]


:12.8. For the first-fit heuristic described just above, give an example where the packing it finds uses at least 5/3 times as many bins as optimal.


:[[12.9]]. Given an undirected graph &lt;math&gt;G = (V, E)&lt;/math&gt; in which each node has degree ≤ d, show how to efficiently find an independent set whose size is at least &lt;math&gt;1/(d + 1)&lt;/math&gt; times that of the largest independent set.
[[12.9|Solution]]


:12.10. A vertex coloring of graph &lt;math&gt;G = (V, E)&lt;/math&gt; is an assignment of colors to vertices of &lt;math&gt;V&lt;/math&gt; such that each edge &lt;math&gt;(x, y)&lt;/math&gt; implies that vertices &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt; are assigned different colors. Give an algorithm for vertex coloring &lt;math&gt;G&lt;/math&gt; using at most &lt;math&gt;\Delta + 1&lt;/math&gt; colors, where &lt;math&gt;\Delta&lt;/math&gt; is the maximum vertex degree of &lt;math&gt;G&lt;/math&gt;.


:[[12.11]]. Show that you can solve any given Sudoku puzzle by finding the minimum vertex coloring of a specific, appropriately constructed (9×9)+9 vertex graph.
[[12.11|Solution]]

===Combinatorial Optimization===
For each of the problems below, design and implement a simulated annealing heuristic to get reasonable solutions. How well does your program perform in practice?


:12.12. Design and implement a heuristic for the bandwidth minimization problem discussed in Section 16.2 (page 470).


:[[12.13]]. Design and implement a heuristic for the maximum satisfiability problem discussed in Section 17.10 (page 537).
[[12.13|Solution]]


:12.14. Design and implement a heuristic for the maximum clique problem discussed in Section 19.1 (page 586).


:[[12.15]]. Design and implement a heuristic for the minimum vertex coloring problem discussed in Section 19.7 (page 604).
[[12.15|Solution]]


:12.16. Design and implement a heuristic for the minimum edge coloring problem discussed in Section 19.8 (page 608).


:[[12.17]]. Design and implement a heuristic for the minimum feedback vertex set problem discussed in Section 19.11 (page 618).
[[12.7|Solution]]


:12.18. Design and implement a heuristic for the set cover problem discussed in Section 21.1 (page 678).

==="Quantum" Computing===

:[[12.19]]. Consider an &lt;math&gt;n&lt;/math&gt; qubit “quantum” system &lt;math&gt;Q&lt;/math&gt;, where each of the &lt;math&gt;N = 2^n&lt;/math&gt; states start out with equal probability &lt;math&gt;p(i) = 1/2^n&lt;/math&gt;. Say the ''Jack''&lt;math&gt;(Q, 0^n)&lt;/math&gt; operation doubles the probability of the state where all qubits are zero. How many calls to this ''Jack'' operation are necessary until the probability of sampling this null state becomes ≥ 1/2?
[[12.19|Solution]]


:12.20. For the satisfiability problem, construct (a) an instance on &lt;math&gt;n&lt;/math&gt; variables that has exactly one solution, and (b) an instance on &lt;math&gt;n&lt;/math&gt; variables that has exactly &lt;math&gt;2^n&lt;/math&gt; different solutions.


:[[12.21]]. Consider the first ten multiples of 11, namely 11, 22, . . . 110. Pick two of them (&lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt;) at random. What is the probability that ''gcd''&lt;math&gt;(x, y) = 11&lt;/math&gt;?
[[12.21|Solution]]


:12.22. IBM quantum computing (https://www.ibm.com/quantum-computing/) offers the opportunity to program a quantum computing simulator. Take a look at an example quantum computing program and run it to see what happens.


Back to [[Chapter List]]</text>
      <sha1>qhv2ymj47yle0q4ci0obvjcaufrhu6n</sha1>
    </revision>
    <revision>
      <id>173</id>
      <parentid>166</parentid>
      <timestamp>2020-09-10T21:10:21Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Combinatorial Optimization */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="7057">=Dealing with Hard Problems=\

===Special Cases of Hard Problems===

:[[12.1]]. Dominos are tiles represented by integer pairs &lt;math&gt;(x_i, y_i)&lt;/math&gt;, where each of the values &lt;math&gt;x_i&lt;/math&gt; and &lt;math&gt;y_i&lt;/math&gt; are integers between 1 and &lt;math&gt;n&lt;/math&gt;. Let &lt;math&gt;S&lt;/math&gt; be a sequence of m integer pairs &lt;math&gt;[(x_1, y_1),(x_2, y_2), ...,(x_m, y_m)]&lt;/math&gt;. The goal of the game is to create long chains &lt;math&gt;[(x_{i1}, y_{i1}),(x_{i2}, y_{i2}), ...,(x_{it}, y_{it})]&lt;/math&gt; such that &lt;math&gt;y_{ij} = x_{i(j+1)}&lt;/math&gt;. Dominos can be flipped, so &lt;math&gt;(x_i, y_i)&lt;/math&gt; equivalent to &lt;math&gt;(y_i, x_i)&lt;/math&gt;. For &lt;math&gt;S = [(1, 3),(4, 2),(3, 5),(2, 3),(3, 8)]&lt;/math&gt;, the longest domino sequences include &lt;math&gt;[(4, 2),(2, 3),(3, 8)]&lt;/math&gt; and &lt;math&gt;[(1, 3),(3, 2),(2, 4)]&lt;/math&gt;.
::(a) Prove that finding the longest domino chain is NP-complete.
::(b) Give an efficient algorithm to find the longest domino chain where the numbers increase along the chain. For S above, the longest such chains are &lt;math&gt;[(1, 3),(3, 5)]&lt;/math&gt; and &lt;math&gt;[(2, 3),(3, 5)]&lt;/math&gt;.
[[12.1|Solution]]


:12.2. Let &lt;math&gt;G = (V, E)&lt;/math&gt; be a graph and &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt; be two distinct vertices of &lt;math&gt;G&lt;/math&gt;. Each vertex &lt;math&gt;v&lt;/math&gt; contains a given number of tokens &lt;math&gt;t(v)&lt;/math&gt; that you can collect if you visit &lt;math&gt;v&lt;/math&gt;.
::(a) Prove that it is NP-complete to find the path from &lt;math&gt;x&lt;/math&gt; to &lt;math&gt;y&lt;/math&gt; where you can collect the greatest possible number of tokens.
::(b) Give an efficient algorithm if &lt;math&gt;G&lt;/math&gt; is a directed acyclic graph (DAG).


:[[12.3]]. The ''Hamiltonian completion problem'' takes a given graph &lt;math&gt;G&lt;/math&gt; and seeks an algorithm to add the smallest number of edges to &lt;math&gt;G&lt;/math&gt; so that it contains a Hamiltonian cycle. This problem is NP-complete for general graphs; however, it has an efficient algorithm if &lt;math&gt;G&lt;/math&gt; is a tree. Give an efficient and provably correct algorithm to add the minimum number of possible edges to tree &lt;math&gt;T&lt;/math&gt; so that &lt;math&gt;T&lt;/math&gt; plus these edges is Hamiltonian.
[[12.3|Solution]]

===Approximation Algorithms===

:12.4. In the ''maximum satisfiability problem'', we seek a truth assignment that satisfies as many clauses as possible. Give an heuristic that always satisfies at least half as many clauses as the optimal solution.


:[[12.5]]. Consider the following heuristic for vertex cover. Construct a DFS tree of the graph, and delete all the leaves from this tree. What remains must be a vertex cover of the graph. Prove that the size of this cover is at most twice as large as optimal.
[[12.5|Solution]]


:12.6. The ''maximum cut problem'' for a graph &lt;math&gt;G = (V, E)&lt;/math&gt; seeks to partition the vertices &lt;math&gt;V&lt;/math&gt; into disjoint sets &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; so as to maximize the number of edges &lt;math&gt;(a, b) \in E&lt;/math&gt; such that &lt;math&gt;a \in A&lt;/math&gt; and &lt;math&gt;b \in B&lt;/math&gt;. Consider the following heuristic for maximum cut. First assign &lt;math&gt;v_1&lt;/math&gt; to &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;v_2&lt;/math&gt; to &lt;math&gt;B&lt;/math&gt;. For each remaining vertex, assign it to the side that adds the most edges to the cut. Prove that this cut is at least half as large as the optimal cut.


:[[12.7]]. [5] In the ''bin-packing problem'', we are given n objects with weights &lt;math&gt;w_1, w_2, ..., w_n&lt;/math&gt;, respectively. Our goal is to find the smallest number of bins that will hold the &lt;math&gt;n&lt;/math&gt; objects, where each bin has a capacity of at most one kilogram.
:The ''first-fit heuristic'' considers the objects in the order in which they are given. For each object, place it into the first bin that has room for it. If no such bin exists, start a new bin. Prove that this heuristic uses at most twice as many bins as the optimal solution.
[[12.7|Solution]]


:12.8. For the first-fit heuristic described just above, give an example where the packing it finds uses at least 5/3 times as many bins as optimal.


:[[12.9]]. Given an undirected graph &lt;math&gt;G = (V, E)&lt;/math&gt; in which each node has degree ≤ d, show how to efficiently find an independent set whose size is at least &lt;math&gt;1/(d + 1)&lt;/math&gt; times that of the largest independent set.
[[12.9|Solution]]


:12.10. A vertex coloring of graph &lt;math&gt;G = (V, E)&lt;/math&gt; is an assignment of colors to vertices of &lt;math&gt;V&lt;/math&gt; such that each edge &lt;math&gt;(x, y)&lt;/math&gt; implies that vertices &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt; are assigned different colors. Give an algorithm for vertex coloring &lt;math&gt;G&lt;/math&gt; using at most &lt;math&gt;\Delta + 1&lt;/math&gt; colors, where &lt;math&gt;\Delta&lt;/math&gt; is the maximum vertex degree of &lt;math&gt;G&lt;/math&gt;.


:[[12.11]]. Show that you can solve any given Sudoku puzzle by finding the minimum vertex coloring of a specific, appropriately constructed (9×9)+9 vertex graph.
[[12.11|Solution]]

===Combinatorial Optimization===
For each of the problems below, design and implement a simulated annealing heuristic to get reasonable solutions. How well does your program perform in practice?


:12.12. Design and implement a heuristic for the bandwidth minimization problem discussed in Section 16.2 (page 470).


:[[12.13]]. Design and implement a heuristic for the maximum satisfiability problem discussed in Section 17.10 (page 537).
[[12.13|Solution]]


:12.14. Design and implement a heuristic for the maximum clique problem discussed in Section 19.1 (page 586).


:[[12.15]]. Design and implement a heuristic for the minimum vertex coloring problem discussed in Section 19.7 (page 604).
[[12.15|Solution]]


:12.16. Design and implement a heuristic for the minimum edge coloring problem discussed in Section 19.8 (page 608).


:[[12.17]]. Design and implement a heuristic for the minimum feedback vertex set problem discussed in Section 19.11 (page 618).
[[12.17|Solution]]


:12.18. Design and implement a heuristic for the set cover problem discussed in Section 21.1 (page 678).

==="Quantum" Computing===

:[[12.19]]. Consider an &lt;math&gt;n&lt;/math&gt; qubit “quantum” system &lt;math&gt;Q&lt;/math&gt;, where each of the &lt;math&gt;N = 2^n&lt;/math&gt; states start out with equal probability &lt;math&gt;p(i) = 1/2^n&lt;/math&gt;. Say the ''Jack''&lt;math&gt;(Q, 0^n)&lt;/math&gt; operation doubles the probability of the state where all qubits are zero. How many calls to this ''Jack'' operation are necessary until the probability of sampling this null state becomes ≥ 1/2?
[[12.19|Solution]]


:12.20. For the satisfiability problem, construct (a) an instance on &lt;math&gt;n&lt;/math&gt; variables that has exactly one solution, and (b) an instance on &lt;math&gt;n&lt;/math&gt; variables that has exactly &lt;math&gt;2^n&lt;/math&gt; different solutions.


:[[12.21]]. Consider the first ten multiples of 11, namely 11, 22, . . . 110. Pick two of them (&lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt;) at random. What is the probability that ''gcd''&lt;math&gt;(x, y) = 11&lt;/math&gt;?
[[12.21|Solution]]


:12.22. IBM quantum computing (https://www.ibm.com/quantum-computing/) offers the opportunity to program a quantum computing simulator. Take a look at an example quantum computing program and run it to see what happens.


Back to [[Chapter List]]</text>
      <sha1>tov45zm02xc8bepbw6a1sjonww6vc3t</sha1>
    </revision>
    <revision>
      <id>179</id>
      <parentid>173</parentid>
      <timestamp>2020-09-10T21:11:49Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="7056">=Dealing with Hard Problems=

===Special Cases of Hard Problems===

:[[12.1]]. Dominos are tiles represented by integer pairs &lt;math&gt;(x_i, y_i)&lt;/math&gt;, where each of the values &lt;math&gt;x_i&lt;/math&gt; and &lt;math&gt;y_i&lt;/math&gt; are integers between 1 and &lt;math&gt;n&lt;/math&gt;. Let &lt;math&gt;S&lt;/math&gt; be a sequence of m integer pairs &lt;math&gt;[(x_1, y_1),(x_2, y_2), ...,(x_m, y_m)]&lt;/math&gt;. The goal of the game is to create long chains &lt;math&gt;[(x_{i1}, y_{i1}),(x_{i2}, y_{i2}), ...,(x_{it}, y_{it})]&lt;/math&gt; such that &lt;math&gt;y_{ij} = x_{i(j+1)}&lt;/math&gt;. Dominos can be flipped, so &lt;math&gt;(x_i, y_i)&lt;/math&gt; equivalent to &lt;math&gt;(y_i, x_i)&lt;/math&gt;. For &lt;math&gt;S = [(1, 3),(4, 2),(3, 5),(2, 3),(3, 8)]&lt;/math&gt;, the longest domino sequences include &lt;math&gt;[(4, 2),(2, 3),(3, 8)]&lt;/math&gt; and &lt;math&gt;[(1, 3),(3, 2),(2, 4)]&lt;/math&gt;.
::(a) Prove that finding the longest domino chain is NP-complete.
::(b) Give an efficient algorithm to find the longest domino chain where the numbers increase along the chain. For S above, the longest such chains are &lt;math&gt;[(1, 3),(3, 5)]&lt;/math&gt; and &lt;math&gt;[(2, 3),(3, 5)]&lt;/math&gt;.
[[12.1|Solution]]


:12.2. Let &lt;math&gt;G = (V, E)&lt;/math&gt; be a graph and &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt; be two distinct vertices of &lt;math&gt;G&lt;/math&gt;. Each vertex &lt;math&gt;v&lt;/math&gt; contains a given number of tokens &lt;math&gt;t(v)&lt;/math&gt; that you can collect if you visit &lt;math&gt;v&lt;/math&gt;.
::(a) Prove that it is NP-complete to find the path from &lt;math&gt;x&lt;/math&gt; to &lt;math&gt;y&lt;/math&gt; where you can collect the greatest possible number of tokens.
::(b) Give an efficient algorithm if &lt;math&gt;G&lt;/math&gt; is a directed acyclic graph (DAG).


:[[12.3]]. The ''Hamiltonian completion problem'' takes a given graph &lt;math&gt;G&lt;/math&gt; and seeks an algorithm to add the smallest number of edges to &lt;math&gt;G&lt;/math&gt; so that it contains a Hamiltonian cycle. This problem is NP-complete for general graphs; however, it has an efficient algorithm if &lt;math&gt;G&lt;/math&gt; is a tree. Give an efficient and provably correct algorithm to add the minimum number of possible edges to tree &lt;math&gt;T&lt;/math&gt; so that &lt;math&gt;T&lt;/math&gt; plus these edges is Hamiltonian.
[[12.3|Solution]]

===Approximation Algorithms===

:12.4. In the ''maximum satisfiability problem'', we seek a truth assignment that satisfies as many clauses as possible. Give an heuristic that always satisfies at least half as many clauses as the optimal solution.


:[[12.5]]. Consider the following heuristic for vertex cover. Construct a DFS tree of the graph, and delete all the leaves from this tree. What remains must be a vertex cover of the graph. Prove that the size of this cover is at most twice as large as optimal.
[[12.5|Solution]]


:12.6. The ''maximum cut problem'' for a graph &lt;math&gt;G = (V, E)&lt;/math&gt; seeks to partition the vertices &lt;math&gt;V&lt;/math&gt; into disjoint sets &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; so as to maximize the number of edges &lt;math&gt;(a, b) \in E&lt;/math&gt; such that &lt;math&gt;a \in A&lt;/math&gt; and &lt;math&gt;b \in B&lt;/math&gt;. Consider the following heuristic for maximum cut. First assign &lt;math&gt;v_1&lt;/math&gt; to &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;v_2&lt;/math&gt; to &lt;math&gt;B&lt;/math&gt;. For each remaining vertex, assign it to the side that adds the most edges to the cut. Prove that this cut is at least half as large as the optimal cut.


:[[12.7]]. [5] In the ''bin-packing problem'', we are given n objects with weights &lt;math&gt;w_1, w_2, ..., w_n&lt;/math&gt;, respectively. Our goal is to find the smallest number of bins that will hold the &lt;math&gt;n&lt;/math&gt; objects, where each bin has a capacity of at most one kilogram.
:The ''first-fit heuristic'' considers the objects in the order in which they are given. For each object, place it into the first bin that has room for it. If no such bin exists, start a new bin. Prove that this heuristic uses at most twice as many bins as the optimal solution.
[[12.7|Solution]]


:12.8. For the first-fit heuristic described just above, give an example where the packing it finds uses at least 5/3 times as many bins as optimal.


:[[12.9]]. Given an undirected graph &lt;math&gt;G = (V, E)&lt;/math&gt; in which each node has degree ≤ d, show how to efficiently find an independent set whose size is at least &lt;math&gt;1/(d + 1)&lt;/math&gt; times that of the largest independent set.
[[12.9|Solution]]


:12.10. A vertex coloring of graph &lt;math&gt;G = (V, E)&lt;/math&gt; is an assignment of colors to vertices of &lt;math&gt;V&lt;/math&gt; such that each edge &lt;math&gt;(x, y)&lt;/math&gt; implies that vertices &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt; are assigned different colors. Give an algorithm for vertex coloring &lt;math&gt;G&lt;/math&gt; using at most &lt;math&gt;\Delta + 1&lt;/math&gt; colors, where &lt;math&gt;\Delta&lt;/math&gt; is the maximum vertex degree of &lt;math&gt;G&lt;/math&gt;.


:[[12.11]]. Show that you can solve any given Sudoku puzzle by finding the minimum vertex coloring of a specific, appropriately constructed (9×9)+9 vertex graph.
[[12.11|Solution]]

===Combinatorial Optimization===
For each of the problems below, design and implement a simulated annealing heuristic to get reasonable solutions. How well does your program perform in practice?


:12.12. Design and implement a heuristic for the bandwidth minimization problem discussed in Section 16.2 (page 470).


:[[12.13]]. Design and implement a heuristic for the maximum satisfiability problem discussed in Section 17.10 (page 537).
[[12.13|Solution]]


:12.14. Design and implement a heuristic for the maximum clique problem discussed in Section 19.1 (page 586).


:[[12.15]]. Design and implement a heuristic for the minimum vertex coloring problem discussed in Section 19.7 (page 604).
[[12.15|Solution]]


:12.16. Design and implement a heuristic for the minimum edge coloring problem discussed in Section 19.8 (page 608).


:[[12.17]]. Design and implement a heuristic for the minimum feedback vertex set problem discussed in Section 19.11 (page 618).
[[12.17|Solution]]


:12.18. Design and implement a heuristic for the set cover problem discussed in Section 21.1 (page 678).

==="Quantum" Computing===

:[[12.19]]. Consider an &lt;math&gt;n&lt;/math&gt; qubit “quantum” system &lt;math&gt;Q&lt;/math&gt;, where each of the &lt;math&gt;N = 2^n&lt;/math&gt; states start out with equal probability &lt;math&gt;p(i) = 1/2^n&lt;/math&gt;. Say the ''Jack''&lt;math&gt;(Q, 0^n)&lt;/math&gt; operation doubles the probability of the state where all qubits are zero. How many calls to this ''Jack'' operation are necessary until the probability of sampling this null state becomes ≥ 1/2?
[[12.19|Solution]]


:12.20. For the satisfiability problem, construct (a) an instance on &lt;math&gt;n&lt;/math&gt; variables that has exactly one solution, and (b) an instance on &lt;math&gt;n&lt;/math&gt; variables that has exactly &lt;math&gt;2^n&lt;/math&gt; different solutions.


:[[12.21]]. Consider the first ten multiples of 11, namely 11, 22, . . . 110. Pick two of them (&lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt;) at random. What is the probability that ''gcd''&lt;math&gt;(x, y) = 11&lt;/math&gt;?
[[12.21|Solution]]


:12.22. IBM quantum computing (https://www.ibm.com/quantum-computing/) offers the opportunity to program a quantum computing simulator. Take a look at an example quantum computing program and run it to see what happens.


Back to [[Chapter List]]</text>
      <sha1>ijwijszlcwgnhy7acuvmwi94q34ggrr</sha1>
    </revision>
    <revision>
      <id>458</id>
      <parentid>179</parentid>
      <timestamp>2020-10-01T18:11:07Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <minor/>
      <comment>Protected "[[Chapter 12]]" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="7056">=Dealing with Hard Problems=

===Special Cases of Hard Problems===

:[[12.1]]. Dominos are tiles represented by integer pairs &lt;math&gt;(x_i, y_i)&lt;/math&gt;, where each of the values &lt;math&gt;x_i&lt;/math&gt; and &lt;math&gt;y_i&lt;/math&gt; are integers between 1 and &lt;math&gt;n&lt;/math&gt;. Let &lt;math&gt;S&lt;/math&gt; be a sequence of m integer pairs &lt;math&gt;[(x_1, y_1),(x_2, y_2), ...,(x_m, y_m)]&lt;/math&gt;. The goal of the game is to create long chains &lt;math&gt;[(x_{i1}, y_{i1}),(x_{i2}, y_{i2}), ...,(x_{it}, y_{it})]&lt;/math&gt; such that &lt;math&gt;y_{ij} = x_{i(j+1)}&lt;/math&gt;. Dominos can be flipped, so &lt;math&gt;(x_i, y_i)&lt;/math&gt; equivalent to &lt;math&gt;(y_i, x_i)&lt;/math&gt;. For &lt;math&gt;S = [(1, 3),(4, 2),(3, 5),(2, 3),(3, 8)]&lt;/math&gt;, the longest domino sequences include &lt;math&gt;[(4, 2),(2, 3),(3, 8)]&lt;/math&gt; and &lt;math&gt;[(1, 3),(3, 2),(2, 4)]&lt;/math&gt;.
::(a) Prove that finding the longest domino chain is NP-complete.
::(b) Give an efficient algorithm to find the longest domino chain where the numbers increase along the chain. For S above, the longest such chains are &lt;math&gt;[(1, 3),(3, 5)]&lt;/math&gt; and &lt;math&gt;[(2, 3),(3, 5)]&lt;/math&gt;.
[[12.1|Solution]]


:12.2. Let &lt;math&gt;G = (V, E)&lt;/math&gt; be a graph and &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt; be two distinct vertices of &lt;math&gt;G&lt;/math&gt;. Each vertex &lt;math&gt;v&lt;/math&gt; contains a given number of tokens &lt;math&gt;t(v)&lt;/math&gt; that you can collect if you visit &lt;math&gt;v&lt;/math&gt;.
::(a) Prove that it is NP-complete to find the path from &lt;math&gt;x&lt;/math&gt; to &lt;math&gt;y&lt;/math&gt; where you can collect the greatest possible number of tokens.
::(b) Give an efficient algorithm if &lt;math&gt;G&lt;/math&gt; is a directed acyclic graph (DAG).


:[[12.3]]. The ''Hamiltonian completion problem'' takes a given graph &lt;math&gt;G&lt;/math&gt; and seeks an algorithm to add the smallest number of edges to &lt;math&gt;G&lt;/math&gt; so that it contains a Hamiltonian cycle. This problem is NP-complete for general graphs; however, it has an efficient algorithm if &lt;math&gt;G&lt;/math&gt; is a tree. Give an efficient and provably correct algorithm to add the minimum number of possible edges to tree &lt;math&gt;T&lt;/math&gt; so that &lt;math&gt;T&lt;/math&gt; plus these edges is Hamiltonian.
[[12.3|Solution]]

===Approximation Algorithms===

:12.4. In the ''maximum satisfiability problem'', we seek a truth assignment that satisfies as many clauses as possible. Give an heuristic that always satisfies at least half as many clauses as the optimal solution.


:[[12.5]]. Consider the following heuristic for vertex cover. Construct a DFS tree of the graph, and delete all the leaves from this tree. What remains must be a vertex cover of the graph. Prove that the size of this cover is at most twice as large as optimal.
[[12.5|Solution]]


:12.6. The ''maximum cut problem'' for a graph &lt;math&gt;G = (V, E)&lt;/math&gt; seeks to partition the vertices &lt;math&gt;V&lt;/math&gt; into disjoint sets &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; so as to maximize the number of edges &lt;math&gt;(a, b) \in E&lt;/math&gt; such that &lt;math&gt;a \in A&lt;/math&gt; and &lt;math&gt;b \in B&lt;/math&gt;. Consider the following heuristic for maximum cut. First assign &lt;math&gt;v_1&lt;/math&gt; to &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;v_2&lt;/math&gt; to &lt;math&gt;B&lt;/math&gt;. For each remaining vertex, assign it to the side that adds the most edges to the cut. Prove that this cut is at least half as large as the optimal cut.


:[[12.7]]. [5] In the ''bin-packing problem'', we are given n objects with weights &lt;math&gt;w_1, w_2, ..., w_n&lt;/math&gt;, respectively. Our goal is to find the smallest number of bins that will hold the &lt;math&gt;n&lt;/math&gt; objects, where each bin has a capacity of at most one kilogram.
:The ''first-fit heuristic'' considers the objects in the order in which they are given. For each object, place it into the first bin that has room for it. If no such bin exists, start a new bin. Prove that this heuristic uses at most twice as many bins as the optimal solution.
[[12.7|Solution]]


:12.8. For the first-fit heuristic described just above, give an example where the packing it finds uses at least 5/3 times as many bins as optimal.


:[[12.9]]. Given an undirected graph &lt;math&gt;G = (V, E)&lt;/math&gt; in which each node has degree ≤ d, show how to efficiently find an independent set whose size is at least &lt;math&gt;1/(d + 1)&lt;/math&gt; times that of the largest independent set.
[[12.9|Solution]]


:12.10. A vertex coloring of graph &lt;math&gt;G = (V, E)&lt;/math&gt; is an assignment of colors to vertices of &lt;math&gt;V&lt;/math&gt; such that each edge &lt;math&gt;(x, y)&lt;/math&gt; implies that vertices &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt; are assigned different colors. Give an algorithm for vertex coloring &lt;math&gt;G&lt;/math&gt; using at most &lt;math&gt;\Delta + 1&lt;/math&gt; colors, where &lt;math&gt;\Delta&lt;/math&gt; is the maximum vertex degree of &lt;math&gt;G&lt;/math&gt;.


:[[12.11]]. Show that you can solve any given Sudoku puzzle by finding the minimum vertex coloring of a specific, appropriately constructed (9×9)+9 vertex graph.
[[12.11|Solution]]

===Combinatorial Optimization===
For each of the problems below, design and implement a simulated annealing heuristic to get reasonable solutions. How well does your program perform in practice?


:12.12. Design and implement a heuristic for the bandwidth minimization problem discussed in Section 16.2 (page 470).


:[[12.13]]. Design and implement a heuristic for the maximum satisfiability problem discussed in Section 17.10 (page 537).
[[12.13|Solution]]


:12.14. Design and implement a heuristic for the maximum clique problem discussed in Section 19.1 (page 586).


:[[12.15]]. Design and implement a heuristic for the minimum vertex coloring problem discussed in Section 19.7 (page 604).
[[12.15|Solution]]


:12.16. Design and implement a heuristic for the minimum edge coloring problem discussed in Section 19.8 (page 608).


:[[12.17]]. Design and implement a heuristic for the minimum feedback vertex set problem discussed in Section 19.11 (page 618).
[[12.17|Solution]]


:12.18. Design and implement a heuristic for the set cover problem discussed in Section 21.1 (page 678).

==="Quantum" Computing===

:[[12.19]]. Consider an &lt;math&gt;n&lt;/math&gt; qubit “quantum” system &lt;math&gt;Q&lt;/math&gt;, where each of the &lt;math&gt;N = 2^n&lt;/math&gt; states start out with equal probability &lt;math&gt;p(i) = 1/2^n&lt;/math&gt;. Say the ''Jack''&lt;math&gt;(Q, 0^n)&lt;/math&gt; operation doubles the probability of the state where all qubits are zero. How many calls to this ''Jack'' operation are necessary until the probability of sampling this null state becomes ≥ 1/2?
[[12.19|Solution]]


:12.20. For the satisfiability problem, construct (a) an instance on &lt;math&gt;n&lt;/math&gt; variables that has exactly one solution, and (b) an instance on &lt;math&gt;n&lt;/math&gt; variables that has exactly &lt;math&gt;2^n&lt;/math&gt; different solutions.


:[[12.21]]. Consider the first ten multiples of 11, namely 11, 22, . . . 110. Pick two of them (&lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt;) at random. What is the probability that ''gcd''&lt;math&gt;(x, y) = 11&lt;/math&gt;?
[[12.21|Solution]]


:12.22. IBM quantum computing (https://www.ibm.com/quantum-computing/) offers the opportunity to program a quantum computing simulator. Take a look at an example quantum computing program and run it to see what happens.


Back to [[Chapter List]]</text>
      <sha1>ijwijszlcwgnhy7acuvmwi94q34ggrr</sha1>
    </revision>
  </page>
  <page>
    <title>Chapter 2</title>
    <ns>0</ns>
    <id>4</id>
    <revision>
      <id>6</id>
      <timestamp>2020-08-23T18:49:26Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Problems  *[[2.1]]  *2.2  *[[2.3]]  *2.4  *[[2.5]]  *2.6  *2.7  *2.8  *2.9  *2.10  *2.11  *2.12  *2.13  *2.14  *2.15  *2.16  *2.17  *2.18  *2.19  *2.20  *2.21  *2.22  *2.23  *..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="428">Problems

*[[2.1]]

*2.2

*[[2.3]]

*2.4

*[[2.5]]

*2.6

*2.7

*2.8

*2.9

*2.10

*2.11

*2.12

*2.13

*2.14

*2.15

*2.16

*2.17

*2.18

*2.19

*2.20

*2.21

*2.22

*2.23

*2.24

*2.25

*2.26

*2.27

*2.28

*2.29

*2.30

*2.31

*2.32

*2.33

*2.34

*2.35

*2.36

*2.37

*2.38

*2.39

*2.40

*2.41

*2.42

*2.43

*2.44

*2.45

*2.46

*2.47

*2.48

*2.49

*2.50

*2.51

*2.52

*2.53

*2.54

*2.55


Back to [[Problem Solutions]]</text>
      <sha1>byaa7b1s0gm8jkpw71mpyt3celq20qu</sha1>
    </revision>
    <revision>
      <id>13</id>
      <parentid>6</parentid>
      <timestamp>2020-08-23T19:32:56Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="423">Problems

:[[2.1]]

:2.2

:[[2.3]]

"2.4

:[[2.5]]

:2.6

:2.7

:2.8

:2.9

:2.10

:2.11

:2.12

:2.13

:2.14

:2.15

:2.16

:2.17

:2.18

:2.19

:2.20

:2.21

:2.22

:2.23

:2.24

:2.25

:2.26

:2.27

:2.28

:2.29

:2.30

:2.31

:2.32

:2.33

:2.34

:2.35

:2.36

:2.37

:2.38

:2.39

:2.40

:2.41

:2.42

:2.43

:2.44

:2.45

:2.46

:2.47

:2.48

:2.49

:2.50

:2.51

:2.52

:2.53

:2.54

:2.55


Back to [[Chapter List]]</text>
      <sha1>lps507irhbwmfjqykwx6byvfvgujzvr</sha1>
    </revision>
    <revision>
      <id>14</id>
      <parentid>13</parentid>
      <timestamp>2020-08-23T19:33:11Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="423">Problems

:[[2.1]]

:2.2

:[[2.3]]

:2.4

:[[2.5]]

:2.6

:2.7

:2.8

:2.9

:2.10

:2.11

:2.12

:2.13

:2.14

:2.15

:2.16

:2.17

:2.18

:2.19

:2.20

:2.21

:2.22

:2.23

:2.24

:2.25

:2.26

:2.27

:2.28

:2.29

:2.30

:2.31

:2.32

:2.33

:2.34

:2.35

:2.36

:2.37

:2.38

:2.39

:2.40

:2.41

:2.42

:2.43

:2.44

:2.45

:2.46

:2.47

:2.48

:2.49

:2.50

:2.51

:2.52

:2.53

:2.54

:2.55


Back to [[Chapter List]]</text>
      <sha1>jw6uu20ck66vb42j8vrudq2czrn0ejx</sha1>
    </revision>
    <revision>
      <id>76</id>
      <parentid>14</parentid>
      <timestamp>2020-09-03T17:53:25Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="823">Problems

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   '''function''' mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2

:[[2.3]]

:2.4

:[[2.5]]

:2.6

:2.7

:2.8

:2.9

:2.10

:2.11

:2.12

:2.13

:2.14

:2.15

:2.16

:2.17

:2.18

:2.19

:2.20

:2.21

:2.22

:2.23

:2.24

:2.25

:2.26

:2.27

:2.28

:2.29

:2.30

:2.31

:2.32

:2.33

:2.34

:2.35

:2.36

:2.37

:2.38

:2.39

:2.40

:2.41

:2.42

:2.43

:2.44

:2.45

:2.46

:2.47

:2.48

:2.49

:2.50

:2.51

:2.52

:2.53

:2.54

:2.55


Back to [[Chapter List]]</text>
      <sha1>spptuy05jg3yxyk1o18ue4qwyk27t4d</sha1>
    </revision>
    <revision>
      <id>77</id>
      <parentid>76</parentid>
      <timestamp>2020-09-03T17:57:15Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="940">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   '''function''' mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2

:[[2.3]]

:2.4

:[[2.5]]

:2.6

:2.7


===Big Oh===


:2.8

:2.9

:2.10

:2.11

:2.12

:2.13

:2.14

:2.15

:2.16

:2.17

:2.18

:2.19

:2.20

:2.21

:2.22

:2.23

:2.24

:2.25

:2.26

:2.27

:2.28

:2.29

:2.30

:2.31

:2.32

:2.33

:2.34

:2.35

:2.36

===Summations===


:2.37

:2.38

:2.39

:2.40

:2.41

:2.42

:2.43

===Logartihms===


:2.44

:2.45

:2.46

:2.47

===Interview Problems===


:2.48

:2.49

:2.50

:2.51

:2.52

:2.53

:2.54

:2.55


Back to [[Chapter List]]</text>
      <sha1>lgmaxbgbaz5fn1tp6bwlenllporlu5t</sha1>
    </revision>
    <revision>
      <id>78</id>
      <parentid>77</parentid>
      <timestamp>2020-09-03T18:03:38Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Program Analysis */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="2970">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        return(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        return(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
        return(&lt;math&gt;r&lt;/math&gt;)


:[[2.5]]

:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
    end
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8

:2.9

:2.10

:2.11

:2.12

:2.13

:2.14

:2.15

:2.16

:2.17

:2.18

:2.19

:2.20

:2.21

:2.22

:2.23

:2.24

:2.25

:2.26

:2.27

:2.28

:2.29

:2.30

:2.31

:2.32

:2.33

:2.34

:2.35

:2.36

===Summations===


:2.37

:2.38

:2.39

:2.40

:2.41

:2.42

:2.43

===Logartihms===


:2.44

:2.45

:2.46

:2.47

===Interview Problems===


:2.48

:2.49

:2.50

:2.51

:2.52

:2.53

:2.54

:2.55


Back to [[Chapter List]]</text>
      <sha1>88iokmg6yxpzljecy5ldy0lh4gm1s14</sha1>
    </revision>
    <revision>
      <id>79</id>
      <parentid>78</parentid>
      <timestamp>2020-09-03T18:58:06Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Big Oh */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="4299">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        return(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        return(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
        return(&lt;math&gt;r&lt;/math&gt;)


:[[2.5]]

:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
    end
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. #Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.11|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]

:2.12

:2.13

:2.14

:2.15

:2.16

:2.17

:2.18

:2.19

:2.20

:2.21

:2.22

:2.23

:2.24

:2.25

:2.26

:2.27

:2.28

:2.29

:2.30

:2.31

:2.32

:2.33

:2.34

:2.35

:2.36

===Summations===


:2.37

:2.38

:2.39

:2.40

:2.41

:2.42

:2.43

===Logartihms===


:2.44

:2.45

:2.46

:2.47

===Interview Problems===


:2.48

:2.49

:2.50

:2.51

:2.52

:2.53

:2.54

:2.55


Back to [[Chapter List]]</text>
      <sha1>91r1twx1grbxad6icpzqziaif9u4vve</sha1>
    </revision>
    <revision>
      <id>80</id>
      <parentid>79</parentid>
      <timestamp>2020-09-03T19:02:58Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Algorithm Analysis */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="4290">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
        ''return''(r)


:[[2.5]]

:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. #Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.11|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]

:2.12

:2.13

:2.14

:2.15

:2.16

:2.17

:2.18

:2.19

:2.20

:2.21

:2.22

:2.23

:2.24

:2.25

:2.26

:2.27

:2.28

:2.29

:2.30

:2.31

:2.32

:2.33

:2.34

:2.35

:2.36

===Summations===


:2.37

:2.38

:2.39

:2.40

:2.41

:2.42

:2.43

===Logartihms===


:2.44

:2.45

:2.46

:2.47

===Interview Problems===


:2.48

:2.49

:2.50

:2.51

:2.52

:2.53

:2.54

:2.55


Back to [[Chapter List]]</text>
      <sha1>eyqdzuy7rts1tlhfiv3aw0errn8w8o2</sha1>
    </revision>
    <revision>
      <id>81</id>
      <parentid>80</parentid>
      <timestamp>2020-09-03T19:17:37Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Big Oh */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="4920">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
        ''return''(r)


:[[2.5]]

:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. True or False?
#Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.9|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]. For each of the following functions, which of the following asymptotic bounds hold for &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, \Theta(g(n)), \Omega(g(n))&lt;/math&gt;?

[[2.11|Solution]]


:2.12. Prove that &lt;math&gt;n^3 - 3n^2-n+1 = \Theta(n^3)&lt;/math&gt;.


:2.13. Prove that &lt;math&gt;n^2 = O(2^n)&lt;/math&gt;.

[[2.13|Solution]]


:2.14. Prove or disprove: &lt;math&gt;\THeta(n^2) = \Theta(n^2+1).


:[[2.15]]
[[2.15|Solution]]


:2.16


:[[2.17]]

[[2.17|Solution]]


:2.18


:[[2.19]]

[[2.19|Solution]]


:2.20


:[[2.21]]

[[2.21|Solution]]


:2.22


:[[2.23]]

[[2.23|Solution]]


:2.24


:[[2.25]]

[[2.25|Solution]]


:2.26


:[[2.27]]

[[2.27|Solution]]


:2.28


:[[2.29]]

[[2.29|Solution]]


:2.30


:[[2.31]]

[[2.31|Solution]]


:2.32


:[[2.33]]

[[2.33|Solution]]


:2.34


:[[2.35]]

[[2.35|Solution]]


:2.36

===Summations===


:2.37

:2.38

:2.39

:2.40

:2.41

:2.42

:2.43

===Logartihms===


:2.44

:2.45

:2.46

:2.47

===Interview Problems===


:2.48

:2.49

:2.50

:2.51

:2.52

:2.53

:2.54

:2.55


Back to [[Chapter List]]</text>
      <sha1>qepbxqfrvlenerjzz4z46x30b1l1n8u</sha1>
    </revision>
    <revision>
      <id>82</id>
      <parentid>81</parentid>
      <timestamp>2020-09-03T19:18:57Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Big Oh */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="4925">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
        ''return''(r)


:[[2.5]]

:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. True or False?
#Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.9|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]. For each of the following functions, which of the following asymptotic bounds hold for &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;,\Theta(g(n)),\Omega(g(n))&lt;/math&gt;?

[[2.11|Solution]]


:2.12. Prove that &lt;math&gt;n^3 - 3n^2-n+1 = \Theta(n^3)&lt;/math&gt;.


:2.13. Prove that &lt;math&gt;n^2 = O(2^n)&lt;/math&gt;.

[[2.13|Solution]]


:2.14. Prove or disprove: &lt;math&gt;\Theta(n^2) = \Theta(n^2+1)&lt;\math&gt;.


:[[2.15]]
[[2.15|Solution]]


:2.16


:[[2.17]]

[[2.17|Solution]]


:2.18


:[[2.19]]

[[2.19|Solution]]


:2.20


:[[2.21]]

[[2.21|Solution]]


:2.22


:[[2.23]]

[[2.23|Solution]]


:2.24


:[[2.25]]

[[2.25|Solution]]


:2.26


:[[2.27]]

[[2.27|Solution]]


:2.28


:[[2.29]]

[[2.29|Solution]]


:2.30


:[[2.31]]

[[2.31|Solution]]


:2.32


:[[2.33]]

[[2.33|Solution]]


:2.34


:[[2.35]]

[[2.35|Solution]]


:2.36

===Summations===


:2.37

:2.38

:2.39

:2.40

:2.41

:2.42

:2.43

===Logartihms===


:2.44

:2.45

:2.46

:2.47

===Interview Problems===


:2.48

:2.49

:2.50

:2.51

:2.52

:2.53

:2.54

:2.55


Back to [[Chapter List]]</text>
      <sha1>euq7shsh7b9ckjhcuy2xjcx7zzb84r2</sha1>
    </revision>
    <revision>
      <id>83</id>
      <parentid>82</parentid>
      <timestamp>2020-09-03T19:22:33Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Big Oh */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="4918">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
        ''return''(r)


:[[2.5]]

:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. True or False?
#Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.9|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]. For each of the following functions, which of the following asymptotic bounds hold for &lt;math&gt;f(n) = O(g(n)),\Theta(g(n)),\Omega(g(n))&lt;/math&gt;?

[[2.11|Solution]]


:2.12. Prove that &lt;math&gt;n^3 - 3n^2-n+1 = \Theta(n^3)&lt;/math&gt;.


:2.13. Prove that &lt;math&gt;n^2 = O(2^n)&lt;/math&gt;.

[[2.13|Solution]]


:2.14. Prove or disprove: &lt;math&gt;\Theta(n^2) = \Theta(n^2+1)&lt;\math&gt;.


:[[2.15]]
[[2.15|Solution]]


:2.16


:[[2.17]]

[[2.17|Solution]]


:2.18


:[[2.19]]

[[2.19|Solution]]


:2.20


:[[2.21]]

[[2.21|Solution]]


:2.22


:[[2.23]]

[[2.23|Solution]]


:2.24


:[[2.25]]

[[2.25|Solution]]


:2.26


:[[2.27]]

[[2.27|Solution]]


:2.28


:[[2.29]]

[[2.29|Solution]]


:2.30


:[[2.31]]

[[2.31|Solution]]


:2.32


:[[2.33]]

[[2.33|Solution]]


:2.34


:[[2.35]]

[[2.35|Solution]]


:2.36

===Summations===


:2.37

:2.38

:2.39

:2.40

:2.41

:2.42

:2.43

===Logartihms===


:2.44

:2.45

:2.46

:2.47

===Interview Problems===


:2.48

:2.49

:2.50

:2.51

:2.52

:2.53

:2.54

:2.55


Back to [[Chapter List]]</text>
      <sha1>7yg5ftx6wz4uh6xdm7bodur9p97cyp2</sha1>
    </revision>
    <revision>
      <id>84</id>
      <parentid>83</parentid>
      <timestamp>2020-09-03T19:34:05Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Program Analysis */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="5499">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
       ''return''(r)


:[[2.5]]. Consider the following algorithm: (the print operation prints a single asterisk; the operation &lt;math&gt;x = 2x&lt;/math&gt; doubles the value of the variable &lt;math&gt;x&lt;/math&gt;).
    ''for'' &lt;math&gt; k = 1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt;
        &lt;math&gt;x = k&lt;/math&gt;
        ''while'' (&lt;math&gt;x &lt; n&lt;/math&gt;):
           ''print'' '*'
           &lt;math&gt;x = 2x&lt;/math&gt;
:Let &lt;math&gt;f(n)&lt;/math&gt; be the complexity of this algorithm (or equivalently the number of times * is printed). Proivde correct bounds for &lt;math&gt; O(f(n))&lt;/math&gt;, and &lt;math&gt;/Theta(f(n))&lt;/math&gt;, ideally converging on &lt;math&gt;\Theta(f(n))&lt;/math&gt;.


:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. True or False?
#Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.9|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]. For each of the following functions, which of the following asymptotic bounds hold for &lt;math&gt;f(n) = O(g(n)),\Theta(g(n)),\Omega(g(n))&lt;/math&gt;?

[[2.11|Solution]]


:2.12. Prove that &lt;math&gt;n^3 - 3n^2-n+1 = \Theta(n^3)&lt;/math&gt;.


:2.13. Prove that &lt;math&gt;n^2 = O(2^n)&lt;/math&gt;.

[[2.13|Solution]]


:2.14. Prove or disprove: &lt;math&gt;\Theta(n^2) = \Theta(n^2+1)&lt;\math&gt;.


:[[2.15]]
[[2.15|Solution]]


:2.16


:[[2.17]]

[[2.17|Solution]]


:2.18


:[[2.19]]

[[2.19|Solution]]


:2.20


:[[2.21]]

[[2.21|Solution]]


:2.22


:[[2.23]]

[[2.23|Solution]]


:2.24


:[[2.25]]

[[2.25|Solution]]


:2.26


:[[2.27]]

[[2.27|Solution]]


:2.28


:[[2.29]]

[[2.29|Solution]]


:2.30


:[[2.31]]

[[2.31|Solution]]


:2.32


:[[2.33]]

[[2.33|Solution]]


:2.34


:[[2.35]]

[[2.35|Solution]]


:2.36

===Summations===


:2.37

:2.38

:2.39

:2.40

:2.41

:2.42

:2.43

===Logartihms===


:2.44

:2.45

:2.46

:2.47

===Interview Problems===


:2.48

:2.49

:2.50

:2.51

:2.52

:2.53

:2.54

:2.55


Back to [[Chapter List]]</text>
      <sha1>nl2xgcxm6y78t9yir8iql41o6czbyo4</sha1>
    </revision>
    <revision>
      <id>85</id>
      <parentid>84</parentid>
      <timestamp>2020-09-03T19:35:07Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Algorithm Analysis */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="5517">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
       ''return''(r)


:[[2.5]]. Consider the following algorithm: (the print operation prints a single asterisk; the operation &lt;math&gt;x = 2x&lt;/math&gt; doubles the value of the variable &lt;math&gt;x&lt;/math&gt;).
    ''for'' &lt;math&gt; k = 1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt;
        &lt;math&gt;x = k&lt;/math&gt;
        ''while'' (&lt;math&gt;x &lt; n&lt;/math&gt;):
           ''print'' '*'
           &lt;math&gt;x = 2x&lt;/math&gt;
:Let &lt;math&gt;f(n)&lt;/math&gt; be the complexity of this algorithm (or equivalently the number of times * is printed). Proivde correct bounds for &lt;math&gt; O(f(n))&lt;/math&gt;, and &lt;math&gt;/Theta(f(n))&lt;/math&gt;, ideally converging on &lt;math&gt;\Theta(f(n))&lt;/math&gt;.

[[2.5|Solution]]


:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. True or False?
#Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.9|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]. For each of the following functions, which of the following asymptotic bounds hold for &lt;math&gt;f(n) = O(g(n)),\Theta(g(n)),\Omega(g(n))&lt;/math&gt;?

[[2.11|Solution]]


:2.12. Prove that &lt;math&gt;n^3 - 3n^2-n+1 = \Theta(n^3)&lt;/math&gt;.


:2.13. Prove that &lt;math&gt;n^2 = O(2^n)&lt;/math&gt;.

[[2.13|Solution]]


:2.14. Prove or disprove: &lt;math&gt;\Theta(n^2) = \Theta(n^2+1)&lt;\math&gt;.


:[[2.15]]
[[2.15|Solution]]


:2.16


:[[2.17]]

[[2.17|Solution]]


:2.18


:[[2.19]]

[[2.19|Solution]]


:2.20


:[[2.21]]

[[2.21|Solution]]


:2.22


:[[2.23]]

[[2.23|Solution]]


:2.24


:[[2.25]]

[[2.25|Solution]]


:2.26


:[[2.27]]

[[2.27|Solution]]


:2.28


:[[2.29]]

[[2.29|Solution]]


:2.30


:[[2.31]]

[[2.31|Solution]]


:2.32


:[[2.33]]

[[2.33|Solution]]


:2.34


:[[2.35]]

[[2.35|Solution]]


:2.36

===Summations===


:2.37

:2.38

:2.39

:2.40

:2.41

:2.42

:2.43

===Logartihms===


:2.44

:2.45

:2.46

:2.47

===Interview Problems===


:2.48

:2.49

:2.50

:2.51

:2.52

:2.53

:2.54

:2.55


Back to [[Chapter List]]</text>
      <sha1>abla71sfrbooxpsjyc9bv9qge0k1fr4</sha1>
    </revision>
    <revision>
      <id>86</id>
      <parentid>85</parentid>
      <timestamp>2020-09-03T21:07:03Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Big Oh */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="6361">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
       ''return''(r)


:[[2.5]]. Consider the following algorithm: (the print operation prints a single asterisk; the operation &lt;math&gt;x = 2x&lt;/math&gt; doubles the value of the variable &lt;math&gt;x&lt;/math&gt;).
    ''for'' &lt;math&gt; k = 1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt;
        &lt;math&gt;x = k&lt;/math&gt;
        ''while'' (&lt;math&gt;x &lt; n&lt;/math&gt;):
           ''print'' '*'
           &lt;math&gt;x = 2x&lt;/math&gt;
:Let &lt;math&gt;f(n)&lt;/math&gt; be the complexity of this algorithm (or equivalently the number of times * is printed). Proivde correct bounds for &lt;math&gt; O(f(n))&lt;/math&gt;, and &lt;math&gt;/Theta(f(n))&lt;/math&gt;, ideally converging on &lt;math&gt;\Theta(f(n))&lt;/math&gt;.

[[2.5|Solution]]


:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. True or False?
#Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.9|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]. For each of the following functions, which of the following asymptotic bounds hold for &lt;math&gt;f(n) = O(g(n)),\Theta(g(n)),\Omega(g(n))&lt;/math&gt;?

[[2.11|Solution]]


:2.12. Prove that &lt;math&gt;n^3 - 3n^2-n+1 = \Theta(n^3)&lt;/math&gt;.


:2.13. Prove that &lt;math&gt;n^2 = O(2^n)&lt;/math&gt;.

[[2.13|Solution]]


:2.14. Prove or disprove: &lt;math&gt;\Theta(n^2) = \Theta(n^2+1)&lt;/math&gt;.


:[[2.15]]. Suppose you have algorithms with the five running times listed below. (Assume these are the exact running times.) How much slower do each of these inputs get when you (a) double the input size, or (b) increase the input size by one?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;
[[2.15|Solution]]


:2.16.  Suppose you have algorithms with the six running times listed below. (Assume these are the exact number of operations performed as a function of input size &lt;math&gt;n&lt;/math&gt;.)Suppose you have a computer that can perform &lt;math&gt;10^10&lt;/math&gt; operations per second. For each algorithm, what is the largest input size n that you can complete within an hour?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;  (f) &lt;math&gt;2^{2^n}&lt;/math&gt;


:[[2.17]]

[[2.17|Solution]]


:2.18


:[[2.19]]

[[2.19|Solution]]


:2.20


:[[2.21]]

[[2.21|Solution]]


:2.22


:[[2.23]]

[[2.23|Solution]]


:2.24


:[[2.25]]

[[2.25|Solution]]


:2.26


:[[2.27]]

[[2.27|Solution]]


:2.28


:[[2.29]]

[[2.29|Solution]]


:2.30


:[[2.31]]

[[2.31|Solution]]


:2.32


:[[2.33]]

[[2.33|Solution]]


:2.34


:[[2.35]]

[[2.35|Solution]]


:2.36

===Summations===


:2.37

:2.38

:2.39

:2.40

:2.41

:2.42

:2.43

===Logartihms===


:2.44

:2.45

:2.46

:2.47

===Interview Problems===


:2.48

:2.49

:2.50

:2.51

:2.52

:2.53

:2.54

:2.55


Back to [[Chapter List]]</text>
      <sha1>jk2mbwc2jkmdcblytwlakbltvwxxiy5</sha1>
    </revision>
    <revision>
      <id>87</id>
      <parentid>86</parentid>
      <timestamp>2020-09-07T16:33:56Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Big Oh */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="7845">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
       ''return''(r)


:[[2.5]]. Consider the following algorithm: (the print operation prints a single asterisk; the operation &lt;math&gt;x = 2x&lt;/math&gt; doubles the value of the variable &lt;math&gt;x&lt;/math&gt;).
    ''for'' &lt;math&gt; k = 1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt;
        &lt;math&gt;x = k&lt;/math&gt;
        ''while'' (&lt;math&gt;x &lt; n&lt;/math&gt;):
           ''print'' '*'
           &lt;math&gt;x = 2x&lt;/math&gt;
:Let &lt;math&gt;f(n)&lt;/math&gt; be the complexity of this algorithm (or equivalently the number of times * is printed). Proivde correct bounds for &lt;math&gt; O(f(n))&lt;/math&gt;, and &lt;math&gt;/Theta(f(n))&lt;/math&gt;, ideally converging on &lt;math&gt;\Theta(f(n))&lt;/math&gt;.

[[2.5|Solution]]


:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. True or False?
#Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.9|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]. For each of the following functions, which of the following asymptotic bounds hold for &lt;math&gt;f(n) = O(g(n)),\Theta(g(n)),\Omega(g(n))&lt;/math&gt;?

[[2.11|Solution]]


:2.12. Prove that &lt;math&gt;n^3 - 3n^2-n+1 = \Theta(n^3)&lt;/math&gt;.


:2.13. Prove that &lt;math&gt;n^2 = O(2^n)&lt;/math&gt;.

[[2.13|Solution]]


:2.14. Prove or disprove: &lt;math&gt;\Theta(n^2) = \Theta(n^2+1)&lt;/math&gt;.


:[[2.15]]. Suppose you have algorithms with the five running times listed below. (Assume these are the exact running times.) How much slower do each of these inputs get when you (a) double the input size, or (b) increase the input size by one?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;
[[2.15|Solution]]


:2.16.  Suppose you have algorithms with the six running times listed below. (Assume these are the exact number of operations performed as a function of input size &lt;math&gt;n&lt;/math&gt;.)Suppose you have a computer that can perform &lt;math&gt;10^10&lt;/math&gt; operations per second. For each algorithm, what is the largest input size n that you can complete within an hour?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;  (f) &lt;math&gt;2^{2^n}&lt;/math&gt;


:[[2.17]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, give an appropriate positive constant &lt;math&gt;c&lt;/math&gt; such that &lt;math&gt;f(n) \leq c \cdot g(n)&lt;/math&gt; for all &lt;math&gt;n &gt; 1&lt;/math&gt;.
#&lt;math&gt;f(n)=n^2+n+1&lt;/math&gt;, &lt;math&gt;g(n)=2n^3&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n + n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^2&lt;/math&gt;
#&lt;math&gt;f(n)=n^2-n+1&lt;/math&gt;, &lt;math&gt;g(n)=n^2/2&lt;/math&gt;


[[2.17|Solution]]


:2.18. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n) = O(g_1(n)+g_2(n))&lt;/math&gt;.


:[[2.19]]. Prove that if &lt;math&gt;f_1(N)=\Omega(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=\Omega(g_2(n) &lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n)=\Omega(g_1(n)+g_2(n))&lt;/math&gt;.

[[2.19|Solution]]


:2.20. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n) \cdot f_2(n) = O(g_1(n) \cdot g_2(n))&lt;/math&gt;


:[[2.21]]. Prove for all &lt;math&gt;k \geq 1&lt;/math&gt; and all sets of constants &lt;math&gt;\{a_k, a_{k-1}, \ldots, a_1,a_0\} \in R&lt;/math&gt;, &lt;math&gt; a_k n^k + a_{k-1}n^{k-1}+....+a_1 n + a_0 = O(n^k)&lt;/math&gt;

[[2.21|Solution]]


:2.22. Show that for any real constants &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;, &lt;math&gt;b &gt; 0&lt;/math&gt;
&lt;center&gt;&lt;math&gt;(n + a)^b = \Omega (n^b)&lt;/math&gt;&lt;/center&gt;


:[[2.23]]. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{llll}
n &amp; 2^n &amp; n \lg n &amp; \ln n \\
n-n^3+7n^5 &amp; \lg n &amp; \sqrt n &amp; e^n \\
n^2+\lg n &amp; n^2 &amp; 2^{n-1} &amp;  \lg \lg n \\
n^3 &amp; (\lg n)^2 &amp; n! &amp; n^{1+\varepsilon} where 0&lt; \varepsilon &lt;1
\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.23|Solution]]


:2.24


:[[2.25]]

[[2.25|Solution]]


:2.26


:[[2.27]]

[[2.27|Solution]]


:2.28


:[[2.29]]

[[2.29|Solution]]


:2.30


:[[2.31]]

[[2.31|Solution]]


:2.32


:[[2.33]]

[[2.33|Solution]]


:2.34


:[[2.35]]

[[2.35|Solution]]


:2.36

===Summations===


:2.37

:2.38

:2.39

:2.40

:2.41

:2.42

:2.43

===Logartihms===


:2.44

:2.45

:2.46

:2.47

===Interview Problems===


:2.48

:2.49

:2.50

:2.51

:2.52

:2.53

:2.54

:2.55


Back to [[Chapter List]]</text>
      <sha1>6w6hivi0m336xvco8bbcutm9ppyimss</sha1>
    </revision>
    <revision>
      <id>88</id>
      <parentid>87</parentid>
      <timestamp>2020-09-07T16:40:22Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Big Oh */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="12119">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
       ''return''(r)


:[[2.5]]. Consider the following algorithm: (the print operation prints a single asterisk; the operation &lt;math&gt;x = 2x&lt;/math&gt; doubles the value of the variable &lt;math&gt;x&lt;/math&gt;).
    ''for'' &lt;math&gt; k = 1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt;
        &lt;math&gt;x = k&lt;/math&gt;
        ''while'' (&lt;math&gt;x &lt; n&lt;/math&gt;):
           ''print'' '*'
           &lt;math&gt;x = 2x&lt;/math&gt;
:Let &lt;math&gt;f(n)&lt;/math&gt; be the complexity of this algorithm (or equivalently the number of times * is printed). Proivde correct bounds for &lt;math&gt; O(f(n))&lt;/math&gt;, and &lt;math&gt;/Theta(f(n))&lt;/math&gt;, ideally converging on &lt;math&gt;\Theta(f(n))&lt;/math&gt;.

[[2.5|Solution]]


:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. True or False?
#Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.9|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]. For each of the following functions, which of the following asymptotic bounds hold for &lt;math&gt;f(n) = O(g(n)),\Theta(g(n)),\Omega(g(n))&lt;/math&gt;?

[[2.11|Solution]]


:2.12. Prove that &lt;math&gt;n^3 - 3n^2-n+1 = \Theta(n^3)&lt;/math&gt;.


:2.13. Prove that &lt;math&gt;n^2 = O(2^n)&lt;/math&gt;.

[[2.13|Solution]]


:2.14. Prove or disprove: &lt;math&gt;\Theta(n^2) = \Theta(n^2+1)&lt;/math&gt;.


:[[2.15]]. Suppose you have algorithms with the five running times listed below. (Assume these are the exact running times.) How much slower do each of these inputs get when you (a) double the input size, or (b) increase the input size by one?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;

[[2.15|Solution]]


:2.16.  Suppose you have algorithms with the six running times listed below. (Assume these are the exact number of operations performed as a function of input size &lt;math&gt;n&lt;/math&gt;.)Suppose you have a computer that can perform &lt;math&gt;10^10&lt;/math&gt; operations per second. For each algorithm, what is the largest input size n that you can complete within an hour?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;  (f) &lt;math&gt;2^{2^n}&lt;/math&gt;


:[[2.17]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, give an appropriate positive constant &lt;math&gt;c&lt;/math&gt; such that &lt;math&gt;f(n) \leq c \cdot g(n)&lt;/math&gt; for all &lt;math&gt;n &gt; 1&lt;/math&gt;.
#&lt;math&gt;f(n)=n^2+n+1&lt;/math&gt;, &lt;math&gt;g(n)=2n^3&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n + n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^2&lt;/math&gt;
#&lt;math&gt;f(n)=n^2-n+1&lt;/math&gt;, &lt;math&gt;g(n)=n^2/2&lt;/math&gt;


[[2.17|Solution]]


:2.18. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n) = O(g_1(n)+g_2(n))&lt;/math&gt;.


:[[2.19]]. Prove that if &lt;math&gt;f_1(N)=\Omega(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=\Omega(g_2(n) &lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n)=\Omega(g_1(n)+g_2(n))&lt;/math&gt;.

[[2.19|Solution]]


:2.20. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n) \cdot f_2(n) = O(g_1(n) \cdot g_2(n))&lt;/math&gt;


:[[2.21]]. Prove for all &lt;math&gt;k \geq 1&lt;/math&gt; and all sets of constants &lt;math&gt;\{a_k, a_{k-1}, \ldots, a_1,a_0\} \in R&lt;/math&gt;, &lt;math&gt; a_k n^k + a_{k-1}n^{k-1}+....+a_1 n + a_0 = O(n^k)&lt;/math&gt;

[[2.21|Solution]]


:2.22. Show that for any real constants &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;, &lt;math&gt;b &gt; 0&lt;/math&gt;
&lt;center&gt;&lt;math&gt;(n + a)^b = \Omega (n^b)&lt;/math&gt;&lt;/center&gt;


:[[2.23]]. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{llll}
n &amp; 2^n &amp; n \lg n &amp; \ln n \\
n-n^3+7n^5 &amp; \lg n &amp; \sqrt n &amp; e^n \\
n^2+\lg n &amp; n^2 &amp; 2^{n-1} &amp;  \lg \lg n \\
n^3 &amp; (\lg n)^2 &amp; n! &amp; n^{1+\varepsilon} where 0&lt; \varepsilon &lt;1
\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.23|Solution]]


:2.24


:[[2.25]]

[[2.25|Solution]]


:2.26. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{lll}
\sqrt{n} &amp; n &amp; 2^n \\
n \log n &amp;  n - n^3 + 7n^5 &amp;  n^2 + \log n \\
n^2 &amp;  n^3 &amp;  \log n \\
n^{\frac{1}{3}} + \log n &amp; (\log n)^2 &amp;  n! \\
\ln n &amp; \frac{n}{\log n} &amp;  \log \log n \\
({1}/{3})^n &amp;  ({3}/{2})^n &amp;  6 \\
\end{array}&lt;/math&gt;
&lt;/center&gt;


:[[2.27]]. Find two functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt; that satisfy the following relationship. If no such &lt;math&gt;f&lt;/math&gt; and &lt;math&gt;g&lt;/math&gt; exist, write ''None.''
#&lt;math&gt;f(n)=o(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq \Theta(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n)=o(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;

[[2.27|Solution]]


:2.28. True or False?
#&lt;math&gt;2n^2+1=O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n= O(\log n)&lt;/math&gt;
#&lt;math&gt;\log n = O(\sqrt n)&lt;/math&gt;
#&lt;math&gt;n^2(1 + \sqrt n) = O(n^2 \log n)&lt;/math&gt;
#&lt;math&gt;3n^2 + \sqrt n = O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n \log n= O(n) &lt;/math&gt;
#&lt;math&gt;\log n=O(n^{-1/2})&lt;/math&gt;


:[[2.29]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, state whether &lt;math&gt;f(n)=O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;, or none
of the above.
#&lt;math&gt;f(n)=n^2+3n+4&lt;/math&gt;, &lt;math&gt;g(n)=6n+7&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n&lt;/math&gt;, &lt;math&gt;g(n)=n^2-n&lt;/math&gt;
#&lt;math&gt;f(n)=2^n - n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^4+n^2&lt;/math&gt;


[[2.29|Solution]]. 


:2.30. For each of these questions, briefly explain your answer.
&lt;br&gt;
(a) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it
possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
&lt;br&gt;
(b) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it
possible that
it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
&lt;br&gt;
(c) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it
possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
&lt;br&gt;
(d) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time,
is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
&lt;br&gt;
(e) Is the function &lt;math&gt;f(n) = \Theta(n^2)&lt;/math&gt;, where &lt;math&gt;f(n) = 100 n^2&lt;/math&gt; for even &lt;math&gt;n&lt;/math&gt;
and &lt;math&gt;f(n) = 20 n^2 - n \log_2 n&lt;/math&gt; for odd &lt;math&gt;n&lt;/math&gt;?


:[[2.31]]. For each of the following, answer ''yes'', ''no'', or ''can't tell''. Explain your reasoning.
&lt;br&gt;
(a) Is &lt;math&gt;3^n = O(2^n)&lt;/math&gt;?
&lt;br&gt;
(b) Is &lt;math&gt;\log 3^n = O( \log 2^n )&lt;/math&gt;?
&lt;br&gt;
(c) Is &lt;math&gt;3^n = \Omega(2^n)&lt;/math&gt;?
&lt;br&gt;
(d) Is &lt;math&gt;\log 3^n = \Omega( \log 2^n )&lt;/math&gt;?

[[2.31|Solution]]


:2.32. For each of the following expressions &lt;math&gt;f(n)&lt;/math&gt; find a simple &lt;math&gt;g(n)&lt;/math&gt; such that
&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n {1\over i}&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \lceil {1\over i}\rceil&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \log i&lt;/math&gt;.
#&lt;math&gt;f(n)=\log (n!)&lt;/math&gt;.


:[[2.33]]. Place the following functions into increasing asymptotic order.
&lt;math&gt;f_1(n) = n^2\log_2n&lt;/math&gt;,
&lt;math&gt;f_2(n) = n(\log_2n)^2&lt;/math&gt;,
&lt;math&gt;f_3(n) = \sum_{i=0}^n 2^i&lt;/math&gt;,
&lt;math&gt;f_4(n) = \log_2(\sum_{i=0}^n 2^i)&lt;/math&gt;.


[[2.33|Solution]]


:2.34. Which of the following are true?
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n-1})&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^n)&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n+1})&lt;/math&gt;.


:[[2.35]]. For each of the following functions &lt;math&gt;f&lt;/math&gt; find a simple function &lt;math&gt;g&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f_1(n)= (1000)2^n + 4^n&lt;/math&gt;.
#&lt;math&gt;f_2(n)= n + n\log n + \sqrt n&lt;/math&gt;.
#&lt;math&gt;f_3(n)= \log (n^{20}) + (\log n)^{10}&lt;/math&gt;.
#&lt;math&gt;f_4(n)= (0.99)^n + n^{100}.&lt;/math&gt;

[[2.35|Solution]]


:2.36. For each pair of expressions &lt;math&gt;(A,B)&lt;/math&gt; below,
indicate whether &lt;math&gt;A&lt;/math&gt; is &lt;math&gt;O&lt;/math&gt;, &lt;math&gt;o&lt;/math&gt;, &lt;math&gt;\Omega&lt;/math&gt;, &lt;math&gt;\omega&lt;/math&gt;, or &lt;math&gt;\Theta&lt;/math&gt; of
&lt;math&gt;B&lt;/math&gt;.  Note that zero, one or more of these relations may hold for a
given pair; list all correct ones.
&lt;br&gt;&lt;math&gt;
\begin{array}{lcc}
        &amp; A                     &amp; B \\
(a)     &amp; n^{100}               &amp; 2^n \\
(b)     &amp; (\lg n)^{12}         &amp; \sqrt{n} \\
(c)     &amp; \sqrt{n}              &amp; n^{\cos (\pi n/8)} \\
(d)     &amp; 10^n                  &amp; 100^n \\
(e)     &amp; n^{\lg n}            &amp; (\lg n)^n \\
(f)     &amp; \lg{(n!)}            &amp; n \lg n
\end{array}
&lt;/math&gt;

===Summations===


:2.37

:2.38

:2.39

:2.40

:2.41

:2.42

:2.43

===Logartihms===


:2.44

:2.45

:2.46

:2.47

===Interview Problems===


:2.48

:2.49

:2.50

:2.51

:2.52

:2.53

:2.54

:2.55


Back to [[Chapter List]]</text>
      <sha1>hqw8ghd6myln0l1j5hv4arjp9fu7z1h</sha1>
    </revision>
    <revision>
      <id>89</id>
      <parentid>88</parentid>
      <timestamp>2020-09-07T16:45:19Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Big Oh */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="12150">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
       ''return''(r)


:[[2.5]]. Consider the following algorithm: (the print operation prints a single asterisk; the operation &lt;math&gt;x = 2x&lt;/math&gt; doubles the value of the variable &lt;math&gt;x&lt;/math&gt;).
    ''for'' &lt;math&gt; k = 1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt;
        &lt;math&gt;x = k&lt;/math&gt;
        ''while'' (&lt;math&gt;x &lt; n&lt;/math&gt;):
           ''print'' '*'
           &lt;math&gt;x = 2x&lt;/math&gt;
:Let &lt;math&gt;f(n)&lt;/math&gt; be the complexity of this algorithm (or equivalently the number of times * is printed). Proivde correct bounds for &lt;math&gt; O(f(n))&lt;/math&gt;, and &lt;math&gt;/Theta(f(n))&lt;/math&gt;, ideally converging on &lt;math&gt;\Theta(f(n))&lt;/math&gt;.

[[2.5|Solution]]


:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. True or False?
#Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.9|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]. For each of the following functions, which of the following asymptotic bounds hold for &lt;math&gt;f(n) = O(g(n)),\Theta(g(n)),\Omega(g(n))&lt;/math&gt;?

[[2.11|Solution]]


:2.12. Prove that &lt;math&gt;n^3 - 3n^2-n+1 = \Theta(n^3)&lt;/math&gt;.


:2.13. Prove that &lt;math&gt;n^2 = O(2^n)&lt;/math&gt;.

[[2.13|Solution]]


:2.14. Prove or disprove: &lt;math&gt;\Theta(n^2) = \Theta(n^2+1)&lt;/math&gt;.


:[[2.15]]. Suppose you have algorithms with the five running times listed below. (Assume these are the exact running times.) How much slower do each of these inputs get when you (a) double the input size, or (b) increase the input size by one?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;

[[2.15|Solution]]


:2.16.  Suppose you have algorithms with the six running times listed below. (Assume these are the exact number of operations performed as a function of input size &lt;math&gt;n&lt;/math&gt;.)Suppose you have a computer that can perform &lt;math&gt;10^10&lt;/math&gt; operations per second. For each algorithm, what is the largest input size n that you can complete within an hour?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;  (f) &lt;math&gt;2^{2^n}&lt;/math&gt;


:[[2.17]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, give an appropriate positive constant &lt;math&gt;c&lt;/math&gt; such that &lt;math&gt;f(n) \leq c \cdot g(n)&lt;/math&gt; for all &lt;math&gt;n &gt; 1&lt;/math&gt;.
#&lt;math&gt;f(n)=n^2+n+1&lt;/math&gt;, &lt;math&gt;g(n)=2n^3&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n + n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^2&lt;/math&gt;
#&lt;math&gt;f(n)=n^2-n+1&lt;/math&gt;, &lt;math&gt;g(n)=n^2/2&lt;/math&gt;

[[2.17|Solution]]


:2.18. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n) = O(g_1(n)+g_2(n))&lt;/math&gt;.


:[[2.19]]. Prove that if &lt;math&gt;f_1(N)=\Omega(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=\Omega(g_2(n) &lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n)=\Omega(g_1(n)+g_2(n))&lt;/math&gt;.

[[2.19|Solution]]


:2.20. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n) \cdot f_2(n) = O(g_1(n) \cdot g_2(n))&lt;/math&gt;


:[[2.21]]. Prove for all &lt;math&gt;k \geq 1&lt;/math&gt; and all sets of constants &lt;math&gt;\{a_k, a_{k-1}, \ldots, a_1,a_0\} \in R&lt;/math&gt;, &lt;math&gt; a_k n^k + a_{k-1}n^{k-1}+....+a_1 n + a_0 = O(n^k)&lt;/math&gt;

[[2.21|Solution]]


:2.22. Show that for any real constants &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;, &lt;math&gt;b &gt; 0&lt;/math&gt;
&lt;center&gt;&lt;math&gt;(n + a)^b = \Omega (n^b)&lt;/math&gt;&lt;/center&gt;


:[[2.23]]. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{llll}
n &amp; 2^n &amp; n \lg n &amp; \ln n \\
n-n^3+7n^5 &amp; \lg n &amp; \sqrt n &amp; e^n \\
n^2+\lg n &amp; n^2 &amp; 2^{n-1} &amp;  \lg \lg n \\
n^3 &amp; (\lg n)^2 &amp; n! &amp; n^{1+\varepsilon} where 0&lt; \varepsilon &lt;1
\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.23|Solution]]


:2.24


:[[2.25]]

[[2.25|Solution]]


:2.26. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{lll}
\sqrt{n} &amp; n &amp; 2^n \\
n \log n &amp;  n - n^3 + 7n^5 &amp;  n^2 + \log n \\
n^2 &amp;  n^3 &amp;  \log n \\
n^{\frac{1}{3}} + \log n &amp; (\log n)^2 &amp;  n! \\
\ln n &amp; \frac{n}{\log n} &amp;  \log \log n \\
({1}/{3})^n &amp;  ({3}/{2})^n &amp;  6 \\
\end{array}&lt;/math&gt;
&lt;/center&gt;


:[[2.27]]. Find two functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt; that satisfy the following relationship. If no such &lt;math&gt;f&lt;/math&gt; and &lt;math&gt;g&lt;/math&gt; exist, write ''None.''
#&lt;math&gt;f(n)=o(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq \Theta(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n)=o(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;

[[2.27|Solution]]


:2.28. True or False?
#&lt;math&gt;2n^2+1=O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n= O(\log n)&lt;/math&gt;
#&lt;math&gt;\log n = O(\sqrt n)&lt;/math&gt;
#&lt;math&gt;n^2(1 + \sqrt n) = O(n^2 \log n)&lt;/math&gt;
#&lt;math&gt;3n^2 + \sqrt n = O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n \log n= O(n) &lt;/math&gt;
#&lt;math&gt;\log n=O(n^{-1/2})&lt;/math&gt;


:[[2.29]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, state whether &lt;math&gt;f(n)=O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;, or none of the above.
#&lt;math&gt;f(n)=n^2+3n+4&lt;/math&gt;, &lt;math&gt;g(n)=6n+7&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n&lt;/math&gt;, &lt;math&gt;g(n)=n^2-n&lt;/math&gt;
#&lt;math&gt;f(n)=2^n - n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^4+n^2&lt;/math&gt;

[[2.29|Solution]]. 


:2.30. For each of these questions, briefly explain your answer.
&lt;br&gt;
::(a) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
&lt;br&gt;
::(b) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
&lt;br&gt;
::(c) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
&lt;br&gt;
::(d) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
&lt;br&gt;
::(e) Is the function &lt;math&gt;f(n) = \Theta(n^2)&lt;/math&gt;, where &lt;math&gt;f(n) = 100 n^2&lt;/math&gt; for even &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;f(n) = 20 n^2 - n \log_2 n&lt;/math&gt; for odd &lt;math&gt;n&lt;/math&gt;?


:[[2.31]]. For each of the following, answer ''yes'', ''no'', or ''can't tell''. Explain your reasoning.
&lt;br&gt;
::(a) Is &lt;math&gt;3^n = O(2^n)&lt;/math&gt;?
&lt;br&gt;
::(b) Is &lt;math&gt;\log 3^n = O( \log 2^n )&lt;/math&gt;?
&lt;br&gt;
::(c) Is &lt;math&gt;3^n = \Omega(2^n)&lt;/math&gt;?
&lt;br&gt;
::(d) Is &lt;math&gt;\log 3^n = \Omega( \log 2^n )&lt;/math&gt;?

[[2.31|Solution]]


:2.32. For each of the following expressions &lt;math&gt;f(n)&lt;/math&gt; find a simple &lt;math&gt;g(n)&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
::#&lt;math&gt;f(n)=\sum_{i=1}^n {1\over i}&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \lceil {1\over i}\rceil&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \log i&lt;/math&gt;.
#&lt;math&gt;f(n)=\log (n!)&lt;/math&gt;.


:[[2.33]]. Place the following functions into increasing asymptotic order.
&lt;math&gt;f_1(n) = n^2\log_2n&lt;/math&gt;,
&lt;math&gt;f_2(n) = n(\log_2n)^2&lt;/math&gt;,
&lt;math&gt;f_3(n) = \sum_{i=0}^n 2^i&lt;/math&gt;,
&lt;math&gt;f_4(n) = \log_2(\sum_{i=0}^n 2^i)&lt;/math&gt;.

[[2.33|Solution]]


:2.34. Which of the following are true?
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n-1})&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^n)&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n+1})&lt;/math&gt;.


:[[2.35]]. For each of the following functions &lt;math&gt;f&lt;/math&gt; find a simple function &lt;math&gt;g&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f_1(n)= (1000)2^n + 4^n&lt;/math&gt;.
#&lt;math&gt;f_2(n)= n + n\log n + \sqrt n&lt;/math&gt;.
#&lt;math&gt;f_3(n)= \log (n^{20}) + (\log n)^{10}&lt;/math&gt;.
#&lt;math&gt;f_4(n)= (0.99)^n + n^{100}.&lt;/math&gt;

[[2.35|Solution]]


:2.36. For each pair of expressions &lt;math&gt;(A,B)&lt;/math&gt; below,
indicate whether &lt;math&gt;A&lt;/math&gt; is &lt;math&gt;O&lt;/math&gt;, &lt;math&gt;o&lt;/math&gt;, &lt;math&gt;\Omega&lt;/math&gt;, &lt;math&gt;\omega&lt;/math&gt;, or &lt;math&gt;\Theta&lt;/math&gt; of
&lt;math&gt;B&lt;/math&gt;.  Note that zero, one or more of these relations may hold for a
given pair; list all correct ones.
&lt;br&gt;&lt;math&gt;
\begin{array}{lcc}
::        &amp; A                     &amp; B \\
::(a)     &amp; n^{100}               &amp; 2^n \\
::(b)     &amp; (\lg n)^{12}         &amp; \sqrt{n} \\
::(c)     &amp; \sqrt{n}              &amp; n^{\cos (\pi n/8)} \\
::(d)     &amp; 10^n                  &amp; 100^n \\
::(e)     &amp; n^{\lg n}            &amp; (\lg n)^n \\
::(f)     &amp; \lg{(n!)}            &amp; n \lg n
\end{array}
&lt;/math&gt;

===Summations===


:2.37

:2.38

:2.39

:2.40

:2.41

:2.42

:2.43

===Logartihms===


:2.44

:2.45

:2.46

:2.47

===Interview Problems===


:2.48

:2.49

:2.50

:2.51

:2.52

:2.53

:2.54

:2.55


Back to [[Chapter List]]</text>
      <sha1>3y9th2mjfbr2lfygvx2bhdd23nttnjq</sha1>
    </revision>
    <revision>
      <id>90</id>
      <parentid>89</parentid>
      <timestamp>2020-09-07T16:52:05Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Summations */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="14568">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
       ''return''(r)


:[[2.5]]. Consider the following algorithm: (the print operation prints a single asterisk; the operation &lt;math&gt;x = 2x&lt;/math&gt; doubles the value of the variable &lt;math&gt;x&lt;/math&gt;).
    ''for'' &lt;math&gt; k = 1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt;
        &lt;math&gt;x = k&lt;/math&gt;
        ''while'' (&lt;math&gt;x &lt; n&lt;/math&gt;):
           ''print'' '*'
           &lt;math&gt;x = 2x&lt;/math&gt;
:Let &lt;math&gt;f(n)&lt;/math&gt; be the complexity of this algorithm (or equivalently the number of times * is printed). Proivde correct bounds for &lt;math&gt; O(f(n))&lt;/math&gt;, and &lt;math&gt;/Theta(f(n))&lt;/math&gt;, ideally converging on &lt;math&gt;\Theta(f(n))&lt;/math&gt;.

[[2.5|Solution]]


:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. True or False?
#Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.9|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]. For each of the following functions, which of the following asymptotic bounds hold for &lt;math&gt;f(n) = O(g(n)),\Theta(g(n)),\Omega(g(n))&lt;/math&gt;?

[[2.11|Solution]]


:2.12. Prove that &lt;math&gt;n^3 - 3n^2-n+1 = \Theta(n^3)&lt;/math&gt;.


:2.13. Prove that &lt;math&gt;n^2 = O(2^n)&lt;/math&gt;.

[[2.13|Solution]]


:2.14. Prove or disprove: &lt;math&gt;\Theta(n^2) = \Theta(n^2+1)&lt;/math&gt;.


:[[2.15]]. Suppose you have algorithms with the five running times listed below. (Assume these are the exact running times.) How much slower do each of these inputs get when you (a) double the input size, or (b) increase the input size by one?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;

[[2.15|Solution]]


:2.16.  Suppose you have algorithms with the six running times listed below. (Assume these are the exact number of operations performed as a function of input size &lt;math&gt;n&lt;/math&gt;.)Suppose you have a computer that can perform &lt;math&gt;10^10&lt;/math&gt; operations per second. For each algorithm, what is the largest input size n that you can complete within an hour?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;  (f) &lt;math&gt;2^{2^n}&lt;/math&gt;


:[[2.17]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, give an appropriate positive constant &lt;math&gt;c&lt;/math&gt; such that &lt;math&gt;f(n) \leq c \cdot g(n)&lt;/math&gt; for all &lt;math&gt;n &gt; 1&lt;/math&gt;.
#&lt;math&gt;f(n)=n^2+n+1&lt;/math&gt;, &lt;math&gt;g(n)=2n^3&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n + n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^2&lt;/math&gt;
#&lt;math&gt;f(n)=n^2-n+1&lt;/math&gt;, &lt;math&gt;g(n)=n^2/2&lt;/math&gt;

[[2.17|Solution]]


:2.18. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n) = O(g_1(n)+g_2(n))&lt;/math&gt;.


:[[2.19]]. Prove that if &lt;math&gt;f_1(N)=\Omega(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=\Omega(g_2(n) &lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n)=\Omega(g_1(n)+g_2(n))&lt;/math&gt;.

[[2.19|Solution]]


:2.20. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n) \cdot f_2(n) = O(g_1(n) \cdot g_2(n))&lt;/math&gt;


:[[2.21]]. Prove for all &lt;math&gt;k \geq 1&lt;/math&gt; and all sets of constants &lt;math&gt;\{a_k, a_{k-1}, \ldots, a_1,a_0\} \in R&lt;/math&gt;, &lt;math&gt; a_k n^k + a_{k-1}n^{k-1}+....+a_1 n + a_0 = O(n^k)&lt;/math&gt;

[[2.21|Solution]]


:2.22. Show that for any real constants &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;, &lt;math&gt;b &gt; 0&lt;/math&gt;
&lt;center&gt;&lt;math&gt;(n + a)^b = \Omega (n^b)&lt;/math&gt;&lt;/center&gt;


:[[2.23]]. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{llll}
n &amp; 2^n &amp; n \lg n &amp; \ln n \\
n-n^3+7n^5 &amp; \lg n &amp; \sqrt n &amp; e^n \\
n^2+\lg n &amp; n^2 &amp; 2^{n-1} &amp;  \lg \lg n \\
n^3 &amp; (\lg n)^2 &amp; n! &amp; n^{1+\varepsilon} where 0&lt; \varepsilon &lt;1
\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.23|Solution]]


:2.24


:[[2.25]]

[[2.25|Solution]]


:2.26. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{lll}
\sqrt{n} &amp; n &amp; 2^n \\
n \log n &amp;  n - n^3 + 7n^5 &amp;  n^2 + \log n \\
n^2 &amp;  n^3 &amp;  \log n \\
n^{\frac{1}{3}} + \log n &amp; (\log n)^2 &amp;  n! \\
\ln n &amp; \frac{n}{\log n} &amp;  \log \log n \\
({1}/{3})^n &amp;  ({3}/{2})^n &amp;  6 \\
\end{array}&lt;/math&gt;
&lt;/center&gt;


:[[2.27]]. Find two functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt; that satisfy the following relationship. If no such &lt;math&gt;f&lt;/math&gt; and &lt;math&gt;g&lt;/math&gt; exist, write ''None.''
#&lt;math&gt;f(n)=o(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq \Theta(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n)=o(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;

[[2.27|Solution]]


:2.28. True or False?
#&lt;math&gt;2n^2+1=O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n= O(\log n)&lt;/math&gt;
#&lt;math&gt;\log n = O(\sqrt n)&lt;/math&gt;
#&lt;math&gt;n^2(1 + \sqrt n) = O(n^2 \log n)&lt;/math&gt;
#&lt;math&gt;3n^2 + \sqrt n = O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n \log n= O(n) &lt;/math&gt;
#&lt;math&gt;\log n=O(n^{-1/2})&lt;/math&gt;


:[[2.29]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, state whether &lt;math&gt;f(n)=O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;, or none of the above.
#&lt;math&gt;f(n)=n^2+3n+4&lt;/math&gt;, &lt;math&gt;g(n)=6n+7&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n&lt;/math&gt;, &lt;math&gt;g(n)=n^2-n&lt;/math&gt;
#&lt;math&gt;f(n)=2^n - n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^4+n^2&lt;/math&gt;

[[2.29|Solution]]. 


:2.30. For each of these questions, briefly explain your answer.
&lt;br&gt;
::(a) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
&lt;br&gt;
::(b) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
&lt;br&gt;
::(c) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
&lt;br&gt;
::(d) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
&lt;br&gt;
::(e) Is the function &lt;math&gt;f(n) = \Theta(n^2)&lt;/math&gt;, where &lt;math&gt;f(n) = 100 n^2&lt;/math&gt; for even &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;f(n) = 20 n^2 - n \log_2 n&lt;/math&gt; for odd &lt;math&gt;n&lt;/math&gt;?


:[[2.31]]. For each of the following, answer ''yes'', ''no'', or ''can't tell''. Explain your reasoning.
&lt;br&gt;
::(a) Is &lt;math&gt;3^n = O(2^n)&lt;/math&gt;?
&lt;br&gt;
::(b) Is &lt;math&gt;\log 3^n = O( \log 2^n )&lt;/math&gt;?
&lt;br&gt;
::(c) Is &lt;math&gt;3^n = \Omega(2^n)&lt;/math&gt;?
&lt;br&gt;
::(d) Is &lt;math&gt;\log 3^n = \Omega( \log 2^n )&lt;/math&gt;?

[[2.31|Solution]]


:2.32. For each of the following expressions &lt;math&gt;f(n)&lt;/math&gt; find a simple &lt;math&gt;g(n)&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
::#&lt;math&gt;f(n)=\sum_{i=1}^n {1\over i}&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \lceil {1\over i}\rceil&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \log i&lt;/math&gt;.
#&lt;math&gt;f(n)=\log (n!)&lt;/math&gt;.


:[[2.33]]. Place the following functions into increasing asymptotic order.
&lt;math&gt;f_1(n) = n^2\log_2n&lt;/math&gt;,
&lt;math&gt;f_2(n) = n(\log_2n)^2&lt;/math&gt;,
&lt;math&gt;f_3(n) = \sum_{i=0}^n 2^i&lt;/math&gt;,
&lt;math&gt;f_4(n) = \log_2(\sum_{i=0}^n 2^i)&lt;/math&gt;.

[[2.33|Solution]]


:2.34. Which of the following are true?
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n-1})&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^n)&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n+1})&lt;/math&gt;.


:[[2.35]]. For each of the following functions &lt;math&gt;f&lt;/math&gt; find a simple function &lt;math&gt;g&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f_1(n)= (1000)2^n + 4^n&lt;/math&gt;.
#&lt;math&gt;f_2(n)= n + n\log n + \sqrt n&lt;/math&gt;.
#&lt;math&gt;f_3(n)= \log (n^{20}) + (\log n)^{10}&lt;/math&gt;.
#&lt;math&gt;f_4(n)= (0.99)^n + n^{100}.&lt;/math&gt;

[[2.35|Solution]]


:2.36. For each pair of expressions &lt;math&gt;(A,B)&lt;/math&gt; below,
indicate whether &lt;math&gt;A&lt;/math&gt; is &lt;math&gt;O&lt;/math&gt;, &lt;math&gt;o&lt;/math&gt;, &lt;math&gt;\Omega&lt;/math&gt;, &lt;math&gt;\omega&lt;/math&gt;, or &lt;math&gt;\Theta&lt;/math&gt; of
&lt;math&gt;B&lt;/math&gt;.  Note that zero, one or more of these relations may hold for a
given pair; list all correct ones.
&lt;br&gt;&lt;math&gt;
\begin{array}{lcc}
::        &amp; A                     &amp; B \\
::(a)     &amp; n^{100}               &amp; 2^n \\
::(b)     &amp; (\lg n)^{12}         &amp; \sqrt{n} \\
::(c)     &amp; \sqrt{n}              &amp; n^{\cos (\pi n/8)} \\
::(d)     &amp; 10^n                  &amp; 100^n \\
::(e)     &amp; n^{\lg n}            &amp; (\lg n)^n \\
::(f)     &amp; \lg{(n!)}            &amp; n \lg n
\end{array}
&lt;/math&gt;

===Summations===


:[[2.37]]. Find an expression for the sum of the &lt;math&gt;i&lt;/math&gt;th row of the following triangle, and prove its correctness. Each entry is the sum of the three entries directly above it. All non existing entries are considered 0.
&lt;center&gt;
&lt;math&gt;\begin{array}{ccccccccc}
&amp;&amp;&amp;&amp;1&amp;&amp;&amp;&amp; \\
&amp;&amp;&amp;1&amp;1&amp;1&amp;&amp;&amp;\\
&amp;&amp;1&amp;2&amp;3&amp;2&amp;1&amp;&amp;\\
&amp;1&amp;3&amp;6&amp;7&amp;6&amp;3&amp;1&amp;\\
1&amp;4&amp;10&amp;16&amp;19&amp;16&amp;10&amp;4&amp;1\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.37|Solution]]


:2.38. Assume that Christmas has &lt;math&gt;n&lt;/math&gt; days. Exactly how many presents did my ''true love'' send me? (Do some research if you do not understand this question.)


:[[2.39]]

[[2.39|Solution]]


:2.40. Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n do
      for j=i to 2*i do
         output ''foobar''
&lt;/tt&gt;
:Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as a summation (actually two nested summations).
#Simplify the summation.  Show your work.


:[[2.41]].Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n/2 do
      for j=i to n-i do
         for k=1 to j do
            output ''foobar''
&lt;/tt&gt;
:Assume &lt;math&gt;n&lt;/math&gt; is even. Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as three nested summations.
#Simplify the summation.  Show your work.

[[2.41|Solution]]


:2.42. When you first learned to multiply numbers, you were told that &lt;math&gt;x \times y&lt;/math&gt; means adding &lt;math&gt;x&lt;/math&gt; a total of &lt;math&gt;y&lt;/math&gt; times, so &lt;math&gt;5 \times 4 = 5+5+5+5 = 20&lt;/math&gt;. What is the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers in base &lt;math&gt;b&lt;/math&gt; (people work in base 10, of course, while computers work in base 2) using the repeated addition method, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;. Assume that single-digit by single-digit addition or multiplication takes
&lt;math&gt;O(1)&lt;/math&gt; time. (Hint: how big can &lt;math&gt;y&lt;/math&gt; be as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;?)


:[[2.43]]. In grade school, you learned to multiply long numbers on a digit-by-digit basis, so that &lt;math&gt;127 \times 211 = 127 \times 1 + 127 \times 10 + 127 \times 200 = 26,397&lt;/math&gt;. Analyze the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers with this method as a function of &lt;math&gt;n&lt;/math&gt; (assume constant base size). Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time.

[2.43|Solution]]

===Logartihms===


:2.44

:2.45

:2.46

:2.47

===Interview Problems===


:2.48

:2.49

:2.50

:2.51

:2.52

:2.53

:2.54

:2.55


Back to [[Chapter List]]</text>
      <sha1>ggpi0dqr3nlwk0ihv8qb8lgwk2c5kep</sha1>
    </revision>
    <revision>
      <id>91</id>
      <parentid>90</parentid>
      <timestamp>2020-09-07T16:53:42Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Big Oh */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="14566">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
       ''return''(r)


:[[2.5]]. Consider the following algorithm: (the print operation prints a single asterisk; the operation &lt;math&gt;x = 2x&lt;/math&gt; doubles the value of the variable &lt;math&gt;x&lt;/math&gt;).
    ''for'' &lt;math&gt; k = 1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt;
        &lt;math&gt;x = k&lt;/math&gt;
        ''while'' (&lt;math&gt;x &lt; n&lt;/math&gt;):
           ''print'' '*'
           &lt;math&gt;x = 2x&lt;/math&gt;
:Let &lt;math&gt;f(n)&lt;/math&gt; be the complexity of this algorithm (or equivalently the number of times * is printed). Proivde correct bounds for &lt;math&gt; O(f(n))&lt;/math&gt;, and &lt;math&gt;/Theta(f(n))&lt;/math&gt;, ideally converging on &lt;math&gt;\Theta(f(n))&lt;/math&gt;.

[[2.5|Solution]]


:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. True or False?
#Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.9|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]. For each of the following functions, which of the following asymptotic bounds hold for &lt;math&gt;f(n) = O(g(n)),\Theta(g(n)),\Omega(g(n))&lt;/math&gt;?

[[2.11|Solution]]


:2.12. Prove that &lt;math&gt;n^3 - 3n^2-n+1 = \Theta(n^3)&lt;/math&gt;.


:2.13. Prove that &lt;math&gt;n^2 = O(2^n)&lt;/math&gt;.

[[2.13|Solution]]


:2.14. Prove or disprove: &lt;math&gt;\Theta(n^2) = \Theta(n^2+1)&lt;/math&gt;.


:[[2.15]]. Suppose you have algorithms with the five running times listed below. (Assume these are the exact running times.) How much slower do each of these inputs get when you (a) double the input size, or (b) increase the input size by one?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;

[[2.15|Solution]]


:2.16.  Suppose you have algorithms with the six running times listed below. (Assume these are the exact number of operations performed as a function of input size &lt;math&gt;n&lt;/math&gt;.)Suppose you have a computer that can perform &lt;math&gt;10^10&lt;/math&gt; operations per second. For each algorithm, what is the largest input size n that you can complete within an hour?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;  (f) &lt;math&gt;2^{2^n}&lt;/math&gt;


:[[2.17]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, give an appropriate positive constant &lt;math&gt;c&lt;/math&gt; such that &lt;math&gt;f(n) \leq c \cdot g(n)&lt;/math&gt; for all &lt;math&gt;n &gt; 1&lt;/math&gt;.
#&lt;math&gt;f(n)=n^2+n+1&lt;/math&gt;, &lt;math&gt;g(n)=2n^3&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n + n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^2&lt;/math&gt;
#&lt;math&gt;f(n)=n^2-n+1&lt;/math&gt;, &lt;math&gt;g(n)=n^2/2&lt;/math&gt;

[[2.17|Solution]]


:2.18. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n) = O(g_1(n)+g_2(n))&lt;/math&gt;.


:[[2.19]]. Prove that if &lt;math&gt;f_1(N)=\Omega(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=\Omega(g_2(n) &lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n)=\Omega(g_1(n)+g_2(n))&lt;/math&gt;.

[[2.19|Solution]]


:2.20. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n) \cdot f_2(n) = O(g_1(n) \cdot g_2(n))&lt;/math&gt;


:[[2.21]]. Prove for all &lt;math&gt;k \geq 1&lt;/math&gt; and all sets of constants &lt;math&gt;\{a_k, a_{k-1}, \ldots, a_1,a_0\} \in R&lt;/math&gt;, &lt;math&gt; a_k n^k + a_{k-1}n^{k-1}+....+a_1 n + a_0 = O(n^k)&lt;/math&gt;

[[2.21|Solution]]


:2.22. Show that for any real constants &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;, &lt;math&gt;b &gt; 0&lt;/math&gt;
&lt;center&gt;&lt;math&gt;(n + a)^b = \Omega (n^b)&lt;/math&gt;&lt;/center&gt;


:[[2.23]]. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{llll}
n &amp; 2^n &amp; n \lg n &amp; \ln n \\
n-n^3+7n^5 &amp; \lg n &amp; \sqrt n &amp; e^n \\
n^2+\lg n &amp; n^2 &amp; 2^{n-1} &amp;  \lg \lg n \\
n^3 &amp; (\lg n)^2 &amp; n! &amp; n^{1+\varepsilon} where 0&lt; \varepsilon &lt;1
\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.23|Solution]]


:2.24


:[[2.25]]

[[2.25|Solution]]


:2.26. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{lll}
\sqrt{n} &amp; n &amp; 2^n \\
n \log n &amp;  n - n^3 + 7n^5 &amp;  n^2 + \log n \\
n^2 &amp;  n^3 &amp;  \log n \\
n^{\frac{1}{3}} + \log n &amp; (\log n)^2 &amp;  n! \\
\ln n &amp; \frac{n}{\log n} &amp;  \log \log n \\
({1}/{3})^n &amp;  ({3}/{2})^n &amp;  6 \\
\end{array}&lt;/math&gt;
&lt;/center&gt;


:[[2.27]]. Find two functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt; that satisfy the following relationship. If no such &lt;math&gt;f&lt;/math&gt; and &lt;math&gt;g&lt;/math&gt; exist, write ''None.''
#&lt;math&gt;f(n)=o(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq \Theta(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n)=o(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;

[[2.27|Solution]]


:2.28. True or False?
#&lt;math&gt;2n^2+1=O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n= O(\log n)&lt;/math&gt;
#&lt;math&gt;\log n = O(\sqrt n)&lt;/math&gt;
#&lt;math&gt;n^2(1 + \sqrt n) = O(n^2 \log n)&lt;/math&gt;
#&lt;math&gt;3n^2 + \sqrt n = O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n \log n= O(n) &lt;/math&gt;
#&lt;math&gt;\log n=O(n^{-1/2})&lt;/math&gt;


:[[2.29]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, state whether &lt;math&gt;f(n)=O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;, or none of the above.
#&lt;math&gt;f(n)=n^2+3n+4&lt;/math&gt;, &lt;math&gt;g(n)=6n+7&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n&lt;/math&gt;, &lt;math&gt;g(n)=n^2-n&lt;/math&gt;
#&lt;math&gt;f(n)=2^n - n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^4+n^2&lt;/math&gt;

[[2.29|Solution]]. 


:2.30. For each of these questions, briefly explain your answer.
&lt;br&gt;
::(a) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
&lt;br&gt;
::(b) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
&lt;br&gt;
::(c) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
&lt;br&gt;
::(d) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
&lt;br&gt;
::(e) Is the function &lt;math&gt;f(n) = \Theta(n^2)&lt;/math&gt;, where &lt;math&gt;f(n) = 100 n^2&lt;/math&gt; for even &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;f(n) = 20 n^2 - n \log_2 n&lt;/math&gt; for odd &lt;math&gt;n&lt;/math&gt;?


:[[2.31]]. For each of the following, answer ''yes'', ''no'', or ''can't tell''. Explain your reasoning.
&lt;br&gt;
::(a) Is &lt;math&gt;3^n = O(2^n)&lt;/math&gt;?
&lt;br&gt;
::(b) Is &lt;math&gt;\log 3^n = O( \log 2^n )&lt;/math&gt;?
&lt;br&gt;
::(c) Is &lt;math&gt;3^n = \Omega(2^n)&lt;/math&gt;?
&lt;br&gt;
::(d) Is &lt;math&gt;\log 3^n = \Omega( \log 2^n )&lt;/math&gt;?

[[2.31|Solution]]


:2.32. For each of the following expressions &lt;math&gt;f(n)&lt;/math&gt; find a simple &lt;math&gt;g(n)&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n {1\over i}&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \lceil {1\over i}\rceil&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \log i&lt;/math&gt;.
#&lt;math&gt;f(n)=\log (n!)&lt;/math&gt;.


:[[2.33]]. Place the following functions into increasing asymptotic order.
&lt;math&gt;f_1(n) = n^2\log_2n&lt;/math&gt;,
&lt;math&gt;f_2(n) = n(\log_2n)^2&lt;/math&gt;,
&lt;math&gt;f_3(n) = \sum_{i=0}^n 2^i&lt;/math&gt;,
&lt;math&gt;f_4(n) = \log_2(\sum_{i=0}^n 2^i)&lt;/math&gt;.

[[2.33|Solution]]


:2.34. Which of the following are true?
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n-1})&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^n)&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n+1})&lt;/math&gt;.


:[[2.35]]. For each of the following functions &lt;math&gt;f&lt;/math&gt; find a simple function &lt;math&gt;g&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f_1(n)= (1000)2^n + 4^n&lt;/math&gt;.
#&lt;math&gt;f_2(n)= n + n\log n + \sqrt n&lt;/math&gt;.
#&lt;math&gt;f_3(n)= \log (n^{20}) + (\log n)^{10}&lt;/math&gt;.
#&lt;math&gt;f_4(n)= (0.99)^n + n^{100}.&lt;/math&gt;

[[2.35|Solution]]


:2.36. For each pair of expressions &lt;math&gt;(A,B)&lt;/math&gt; below,
indicate whether &lt;math&gt;A&lt;/math&gt; is &lt;math&gt;O&lt;/math&gt;, &lt;math&gt;o&lt;/math&gt;, &lt;math&gt;\Omega&lt;/math&gt;, &lt;math&gt;\omega&lt;/math&gt;, or &lt;math&gt;\Theta&lt;/math&gt; of
&lt;math&gt;B&lt;/math&gt;.  Note that zero, one or more of these relations may hold for a
given pair; list all correct ones.
&lt;br&gt;&lt;math&gt;
\begin{array}{lcc}
::        &amp; A                     &amp; B \\
::(a)     &amp; n^{100}               &amp; 2^n \\
::(b)     &amp; (\lg n)^{12}         &amp; \sqrt{n} \\
::(c)     &amp; \sqrt{n}              &amp; n^{\cos (\pi n/8)} \\
::(d)     &amp; 10^n                  &amp; 100^n \\
::(e)     &amp; n^{\lg n}            &amp; (\lg n)^n \\
::(f)     &amp; \lg{(n!)}            &amp; n \lg n
\end{array}
&lt;/math&gt;

===Summations===


:[[2.37]]. Find an expression for the sum of the &lt;math&gt;i&lt;/math&gt;th row of the following triangle, and prove its correctness. Each entry is the sum of the three entries directly above it. All non existing entries are considered 0.
&lt;center&gt;
&lt;math&gt;\begin{array}{ccccccccc}
&amp;&amp;&amp;&amp;1&amp;&amp;&amp;&amp; \\
&amp;&amp;&amp;1&amp;1&amp;1&amp;&amp;&amp;\\
&amp;&amp;1&amp;2&amp;3&amp;2&amp;1&amp;&amp;\\
&amp;1&amp;3&amp;6&amp;7&amp;6&amp;3&amp;1&amp;\\
1&amp;4&amp;10&amp;16&amp;19&amp;16&amp;10&amp;4&amp;1\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.37|Solution]]


:2.38. Assume that Christmas has &lt;math&gt;n&lt;/math&gt; days. Exactly how many presents did my ''true love'' send me? (Do some research if you do not understand this question.)


:[[2.39]]

[[2.39|Solution]]


:2.40. Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n do
      for j=i to 2*i do
         output ''foobar''
&lt;/tt&gt;
:Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as a summation (actually two nested summations).
#Simplify the summation.  Show your work.


:[[2.41]].Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n/2 do
      for j=i to n-i do
         for k=1 to j do
            output ''foobar''
&lt;/tt&gt;
:Assume &lt;math&gt;n&lt;/math&gt; is even. Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as three nested summations.
#Simplify the summation.  Show your work.

[[2.41|Solution]]


:2.42. When you first learned to multiply numbers, you were told that &lt;math&gt;x \times y&lt;/math&gt; means adding &lt;math&gt;x&lt;/math&gt; a total of &lt;math&gt;y&lt;/math&gt; times, so &lt;math&gt;5 \times 4 = 5+5+5+5 = 20&lt;/math&gt;. What is the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers in base &lt;math&gt;b&lt;/math&gt; (people work in base 10, of course, while computers work in base 2) using the repeated addition method, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;. Assume that single-digit by single-digit addition or multiplication takes
&lt;math&gt;O(1)&lt;/math&gt; time. (Hint: how big can &lt;math&gt;y&lt;/math&gt; be as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;?)


:[[2.43]]. In grade school, you learned to multiply long numbers on a digit-by-digit basis, so that &lt;math&gt;127 \times 211 = 127 \times 1 + 127 \times 10 + 127 \times 200 = 26,397&lt;/math&gt;. Analyze the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers with this method as a function of &lt;math&gt;n&lt;/math&gt; (assume constant base size). Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time.

[2.43|Solution]]

===Logartihms===


:2.44

:2.45

:2.46

:2.47

===Interview Problems===


:2.48

:2.49

:2.50

:2.51

:2.52

:2.53

:2.54

:2.55


Back to [[Chapter List]]</text>
      <sha1>82ceopwcotk548avnizachvjsr6dkge</sha1>
    </revision>
    <revision>
      <id>92</id>
      <parentid>91</parentid>
      <timestamp>2020-09-07T16:54:41Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Big Oh */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="14568">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
       ''return''(r)


:[[2.5]]. Consider the following algorithm: (the print operation prints a single asterisk; the operation &lt;math&gt;x = 2x&lt;/math&gt; doubles the value of the variable &lt;math&gt;x&lt;/math&gt;).
    ''for'' &lt;math&gt; k = 1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt;
        &lt;math&gt;x = k&lt;/math&gt;
        ''while'' (&lt;math&gt;x &lt; n&lt;/math&gt;):
           ''print'' '*'
           &lt;math&gt;x = 2x&lt;/math&gt;
:Let &lt;math&gt;f(n)&lt;/math&gt; be the complexity of this algorithm (or equivalently the number of times * is printed). Proivde correct bounds for &lt;math&gt; O(f(n))&lt;/math&gt;, and &lt;math&gt;/Theta(f(n))&lt;/math&gt;, ideally converging on &lt;math&gt;\Theta(f(n))&lt;/math&gt;.

[[2.5|Solution]]


:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. True or False?
#Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.9|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]. For each of the following functions, which of the following asymptotic bounds hold for &lt;math&gt;f(n) = O(g(n)),\Theta(g(n)),\Omega(g(n))&lt;/math&gt;?

[[2.11|Solution]]


:2.12. Prove that &lt;math&gt;n^3 - 3n^2-n+1 = \Theta(n^3)&lt;/math&gt;.


:2.13. Prove that &lt;math&gt;n^2 = O(2^n)&lt;/math&gt;.

[[2.13|Solution]]


:2.14. Prove or disprove: &lt;math&gt;\Theta(n^2) = \Theta(n^2+1)&lt;/math&gt;.


:[[2.15]]. Suppose you have algorithms with the five running times listed below. (Assume these are the exact running times.) How much slower do each of these inputs get when you (a) double the input size, or (b) increase the input size by one?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;

[[2.15|Solution]]


:2.16.  Suppose you have algorithms with the six running times listed below. (Assume these are the exact number of operations performed as a function of input size &lt;math&gt;n&lt;/math&gt;.)Suppose you have a computer that can perform &lt;math&gt;10^10&lt;/math&gt; operations per second. For each algorithm, what is the largest input size n that you can complete within an hour?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;  (f) &lt;math&gt;2^{2^n}&lt;/math&gt;


:[[2.17]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, give an appropriate positive constant &lt;math&gt;c&lt;/math&gt; such that &lt;math&gt;f(n) \leq c \cdot g(n)&lt;/math&gt; for all &lt;math&gt;n &gt; 1&lt;/math&gt;.
#&lt;math&gt;f(n)=n^2+n+1&lt;/math&gt;, &lt;math&gt;g(n)=2n^3&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n + n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^2&lt;/math&gt;
#&lt;math&gt;f(n)=n^2-n+1&lt;/math&gt;, &lt;math&gt;g(n)=n^2/2&lt;/math&gt;

[[2.17|Solution]]


:2.18. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n) = O(g_1(n)+g_2(n))&lt;/math&gt;.


:[[2.19]]. Prove that if &lt;math&gt;f_1(N)=\Omega(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=\Omega(g_2(n) &lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n)=\Omega(g_1(n)+g_2(n))&lt;/math&gt;.

[[2.19|Solution]]


:2.20. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n) \cdot f_2(n) = O(g_1(n) \cdot g_2(n))&lt;/math&gt;


:[[2.21]]. Prove for all &lt;math&gt;k \geq 1&lt;/math&gt; and all sets of constants &lt;math&gt;\{a_k, a_{k-1}, \ldots, a_1,a_0\} \in R&lt;/math&gt;, &lt;math&gt; a_k n^k + a_{k-1}n^{k-1}+....+a_1 n + a_0 = O(n^k)&lt;/math&gt;

[[2.21|Solution]]


:2.22. Show that for any real constants &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;, &lt;math&gt;b &gt; 0&lt;/math&gt;
&lt;center&gt;&lt;math&gt;(n + a)^b = \Omega (n^b)&lt;/math&gt;&lt;/center&gt;


:[[2.23]]. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{llll}
n &amp; 2^n &amp; n \lg n &amp; \ln n \\
n-n^3+7n^5 &amp; \lg n &amp; \sqrt n &amp; e^n \\
n^2+\lg n &amp; n^2 &amp; 2^{n-1} &amp;  \lg \lg n \\
n^3 &amp; (\lg n)^2 &amp; n! &amp; n^{1+\varepsilon} where 0&lt; \varepsilon &lt;1
\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.23|Solution]]


:2.24


:[[2.25]]

[[2.25|Solution]]


:2.26. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{lll}
\sqrt{n} &amp; n &amp; 2^n \\
n \log n &amp;  n - n^3 + 7n^5 &amp;  n^2 + \log n \\
n^2 &amp;  n^3 &amp;  \log n \\
n^{\frac{1}{3}} + \log n &amp; (\log n)^2 &amp;  n! \\
\ln n &amp; \frac{n}{\log n} &amp;  \log \log n \\
({1}/{3})^n &amp;  ({3}/{2})^n &amp;  6 \\
\end{array}&lt;/math&gt;
&lt;/center&gt;


:[[2.27]]. Find two functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt; that satisfy the following relationship. If no such &lt;math&gt;f&lt;/math&gt; and &lt;math&gt;g&lt;/math&gt; exist, write ''None.''
#&lt;math&gt;f(n)=o(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq \Theta(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n)=o(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;

[[2.27|Solution]]


:2.28. True or False?
#&lt;math&gt;2n^2+1=O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n= O(\log n)&lt;/math&gt;
#&lt;math&gt;\log n = O(\sqrt n)&lt;/math&gt;
#&lt;math&gt;n^2(1 + \sqrt n) = O(n^2 \log n)&lt;/math&gt;
#&lt;math&gt;3n^2 + \sqrt n = O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n \log n= O(n) &lt;/math&gt;
#&lt;math&gt;\log n=O(n^{-1/2})&lt;/math&gt;


:[[2.29]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, state whether &lt;math&gt;f(n)=O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;, or none of the above.
#&lt;math&gt;f(n)=n^2+3n+4&lt;/math&gt;, &lt;math&gt;g(n)=6n+7&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n&lt;/math&gt;, &lt;math&gt;g(n)=n^2-n&lt;/math&gt;
#&lt;math&gt;f(n)=2^n - n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^4+n^2&lt;/math&gt;

[[2.29|Solution]]. 


:2.30. For each of these questions, briefly explain your answer.
&lt;br&gt;
::(a) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
&lt;br&gt;
::(b) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
&lt;br&gt;
::(c) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
&lt;br&gt;
::(d) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
&lt;br&gt;
::(e) Is the function &lt;math&gt;f(n) = \Theta(n^2)&lt;/math&gt;, where &lt;math&gt;f(n) = 100 n^2&lt;/math&gt; for even &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;f(n) = 20 n^2 - n \log_2 n&lt;/math&gt; for odd &lt;math&gt;n&lt;/math&gt;?


:[[2.31]]. For each of the following, answer ''yes'', ''no'', or ''can't tell''. Explain your reasoning.
&lt;br&gt;
::(a) Is &lt;math&gt;3^n = O(2^n)&lt;/math&gt;?
&lt;br&gt;
::(b) Is &lt;math&gt;\log 3^n = O( \log 2^n )&lt;/math&gt;?
&lt;br&gt;
::(c) Is &lt;math&gt;3^n = \Omega(2^n)&lt;/math&gt;?
&lt;br&gt;
::(d) Is &lt;math&gt;\log 3^n = \Omega( \log 2^n )&lt;/math&gt;?

[[2.31|Solution]]


:2.32. For each of the following expressions &lt;math&gt;f(n)&lt;/math&gt; find a simple &lt;math&gt;g(n)&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n {1\over i}&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \lceil {1\over i}\rceil&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \log i&lt;/math&gt;.
#&lt;math&gt;f(n)=\log (n!)&lt;/math&gt;.


:[[2.33]]. Place the following functions into increasing asymptotic order.
::&lt;math&gt;f_1(n) = n^2\log_2n&lt;/math&gt;,
&lt;math&gt;f_2(n) = n(\log_2n)^2&lt;/math&gt;,
&lt;math&gt;f_3(n) = \sum_{i=0}^n 2^i&lt;/math&gt;,
&lt;math&gt;f_4(n) = \log_2(\sum_{i=0}^n 2^i)&lt;/math&gt;.

[[2.33|Solution]]


:2.34. Which of the following are true?
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n-1})&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^n)&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n+1})&lt;/math&gt;.


:[[2.35]]. For each of the following functions &lt;math&gt;f&lt;/math&gt; find a simple function &lt;math&gt;g&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f_1(n)= (1000)2^n + 4^n&lt;/math&gt;.
#&lt;math&gt;f_2(n)= n + n\log n + \sqrt n&lt;/math&gt;.
#&lt;math&gt;f_3(n)= \log (n^{20}) + (\log n)^{10}&lt;/math&gt;.
#&lt;math&gt;f_4(n)= (0.99)^n + n^{100}.&lt;/math&gt;

[[2.35|Solution]]


:2.36. For each pair of expressions &lt;math&gt;(A,B)&lt;/math&gt; below, indicate whether &lt;math&gt;A&lt;/math&gt; is &lt;math&gt;O&lt;/math&gt;, &lt;math&gt;o&lt;/math&gt;, &lt;math&gt;\Omega&lt;/math&gt;, &lt;math&gt;\omega&lt;/math&gt;, or &lt;math&gt;\Theta&lt;/math&gt; of
&lt;math&gt;B&lt;/math&gt;.  Note that zero, one or more of these relations may hold for a
given pair; list all correct ones.
&lt;br&gt;&lt;math&gt;
\begin{array}{lcc}
::        &amp; A                     &amp; B \\
::(a)     &amp; n^{100}               &amp; 2^n \\
::(b)     &amp; (\lg n)^{12}         &amp; \sqrt{n} \\
::(c)     &amp; \sqrt{n}              &amp; n^{\cos (\pi n/8)} \\
::(d)     &amp; 10^n                  &amp; 100^n \\
::(e)     &amp; n^{\lg n}            &amp; (\lg n)^n \\
::(f)     &amp; \lg{(n!)}            &amp; n \lg n
\end{array}
&lt;/math&gt;

===Summations===


:[[2.37]]. Find an expression for the sum of the &lt;math&gt;i&lt;/math&gt;th row of the following triangle, and prove its correctness. Each entry is the sum of the three entries directly above it. All non existing entries are considered 0.
&lt;center&gt;
&lt;math&gt;\begin{array}{ccccccccc}
&amp;&amp;&amp;&amp;1&amp;&amp;&amp;&amp; \\
&amp;&amp;&amp;1&amp;1&amp;1&amp;&amp;&amp;\\
&amp;&amp;1&amp;2&amp;3&amp;2&amp;1&amp;&amp;\\
&amp;1&amp;3&amp;6&amp;7&amp;6&amp;3&amp;1&amp;\\
1&amp;4&amp;10&amp;16&amp;19&amp;16&amp;10&amp;4&amp;1\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.37|Solution]]


:2.38. Assume that Christmas has &lt;math&gt;n&lt;/math&gt; days. Exactly how many presents did my ''true love'' send me? (Do some research if you do not understand this question.)


:[[2.39]]

[[2.39|Solution]]


:2.40. Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n do
      for j=i to 2*i do
         output ''foobar''
&lt;/tt&gt;
:Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as a summation (actually two nested summations).
#Simplify the summation.  Show your work.


:[[2.41]].Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n/2 do
      for j=i to n-i do
         for k=1 to j do
            output ''foobar''
&lt;/tt&gt;
:Assume &lt;math&gt;n&lt;/math&gt; is even. Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as three nested summations.
#Simplify the summation.  Show your work.

[[2.41|Solution]]


:2.42. When you first learned to multiply numbers, you were told that &lt;math&gt;x \times y&lt;/math&gt; means adding &lt;math&gt;x&lt;/math&gt; a total of &lt;math&gt;y&lt;/math&gt; times, so &lt;math&gt;5 \times 4 = 5+5+5+5 = 20&lt;/math&gt;. What is the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers in base &lt;math&gt;b&lt;/math&gt; (people work in base 10, of course, while computers work in base 2) using the repeated addition method, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;. Assume that single-digit by single-digit addition or multiplication takes
&lt;math&gt;O(1)&lt;/math&gt; time. (Hint: how big can &lt;math&gt;y&lt;/math&gt; be as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;?)


:[[2.43]]. In grade school, you learned to multiply long numbers on a digit-by-digit basis, so that &lt;math&gt;127 \times 211 = 127 \times 1 + 127 \times 10 + 127 \times 200 = 26,397&lt;/math&gt;. Analyze the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers with this method as a function of &lt;math&gt;n&lt;/math&gt; (assume constant base size). Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time.

[2.43|Solution]]

===Logartihms===


:2.44

:2.45

:2.46

:2.47

===Interview Problems===


:2.48

:2.49

:2.50

:2.51

:2.52

:2.53

:2.54

:2.55


Back to [[Chapter List]]</text>
      <sha1>9tam5acw1p49e0sc4kynnna348rlshb</sha1>
    </revision>
    <revision>
      <id>93</id>
      <parentid>92</parentid>
      <timestamp>2020-09-07T16:56:15Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Big Oh */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="14571">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
       ''return''(r)


:[[2.5]]. Consider the following algorithm: (the print operation prints a single asterisk; the operation &lt;math&gt;x = 2x&lt;/math&gt; doubles the value of the variable &lt;math&gt;x&lt;/math&gt;).
    ''for'' &lt;math&gt; k = 1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt;
        &lt;math&gt;x = k&lt;/math&gt;
        ''while'' (&lt;math&gt;x &lt; n&lt;/math&gt;):
           ''print'' '*'
           &lt;math&gt;x = 2x&lt;/math&gt;
:Let &lt;math&gt;f(n)&lt;/math&gt; be the complexity of this algorithm (or equivalently the number of times * is printed). Proivde correct bounds for &lt;math&gt; O(f(n))&lt;/math&gt;, and &lt;math&gt;/Theta(f(n))&lt;/math&gt;, ideally converging on &lt;math&gt;\Theta(f(n))&lt;/math&gt;.

[[2.5|Solution]]


:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. True or False?
#Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.9|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]. For each of the following functions, which of the following asymptotic bounds hold for &lt;math&gt;f(n) = O(g(n)),\Theta(g(n)),\Omega(g(n))&lt;/math&gt;?

[[2.11|Solution]]


:2.12. Prove that &lt;math&gt;n^3 - 3n^2-n+1 = \Theta(n^3)&lt;/math&gt;.


:2.13. Prove that &lt;math&gt;n^2 = O(2^n)&lt;/math&gt;.

[[2.13|Solution]]


:2.14. Prove or disprove: &lt;math&gt;\Theta(n^2) = \Theta(n^2+1)&lt;/math&gt;.


:[[2.15]]. Suppose you have algorithms with the five running times listed below. (Assume these are the exact running times.) How much slower do each of these inputs get when you (a) double the input size, or (b) increase the input size by one?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;

[[2.15|Solution]]


:2.16.  Suppose you have algorithms with the six running times listed below. (Assume these are the exact number of operations performed as a function of input size &lt;math&gt;n&lt;/math&gt;.)Suppose you have a computer that can perform &lt;math&gt;10^10&lt;/math&gt; operations per second. For each algorithm, what is the largest input size n that you can complete within an hour?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;  (f) &lt;math&gt;2^{2^n}&lt;/math&gt;


:[[2.17]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, give an appropriate positive constant &lt;math&gt;c&lt;/math&gt; such that &lt;math&gt;f(n) \leq c \cdot g(n)&lt;/math&gt; for all &lt;math&gt;n &gt; 1&lt;/math&gt;.
#&lt;math&gt;f(n)=n^2+n+1&lt;/math&gt;, &lt;math&gt;g(n)=2n^3&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n + n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^2&lt;/math&gt;
#&lt;math&gt;f(n)=n^2-n+1&lt;/math&gt;, &lt;math&gt;g(n)=n^2/2&lt;/math&gt;

[[2.17|Solution]]


:2.18. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n) = O(g_1(n)+g_2(n))&lt;/math&gt;.


:[[2.19]]. Prove that if &lt;math&gt;f_1(N)=\Omega(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=\Omega(g_2(n) &lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n)=\Omega(g_1(n)+g_2(n))&lt;/math&gt;.

[[2.19|Solution]]


:2.20. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n) \cdot f_2(n) = O(g_1(n) \cdot g_2(n))&lt;/math&gt;


:[[2.21]]. Prove for all &lt;math&gt;k \geq 1&lt;/math&gt; and all sets of constants &lt;math&gt;\{a_k, a_{k-1}, \ldots, a_1,a_0\} \in R&lt;/math&gt;, &lt;math&gt; a_k n^k + a_{k-1}n^{k-1}+....+a_1 n + a_0 = O(n^k)&lt;/math&gt;

[[2.21|Solution]]


:2.22. Show that for any real constants &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;, &lt;math&gt;b &gt; 0&lt;/math&gt;
&lt;center&gt;&lt;math&gt;(n + a)^b = \Omega (n^b)&lt;/math&gt;&lt;/center&gt;


:[[2.23]]. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{llll}
n &amp; 2^n &amp; n \lg n &amp; \ln n \\
n-n^3+7n^5 &amp; \lg n &amp; \sqrt n &amp; e^n \\
n^2+\lg n &amp; n^2 &amp; 2^{n-1} &amp;  \lg \lg n \\
n^3 &amp; (\lg n)^2 &amp; n! &amp; n^{1+\varepsilon} where 0&lt; \varepsilon &lt;1
\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.23|Solution]]


:2.24


:[[2.25]]

[[2.25|Solution]]


:2.26. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{lll}
\sqrt{n} &amp; n &amp; 2^n \\
n \log n &amp;  n - n^3 + 7n^5 &amp;  n^2 + \log n \\
n^2 &amp;  n^3 &amp;  \log n \\
n^{\frac{1}{3}} + \log n &amp; (\log n)^2 &amp;  n! \\
\ln n &amp; \frac{n}{\log n} &amp;  \log \log n \\
({1}/{3})^n &amp;  ({3}/{2})^n &amp;  6 \\
\end{array}&lt;/math&gt;
&lt;/center&gt;


:[[2.27]]. Find two functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt; that satisfy the following relationship. If no such &lt;math&gt;f&lt;/math&gt; and &lt;math&gt;g&lt;/math&gt; exist, write ''None.''
#&lt;math&gt;f(n)=o(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq \Theta(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n)=o(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;

[[2.27|Solution]]


:2.28. True or False?
#&lt;math&gt;2n^2+1=O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n= O(\log n)&lt;/math&gt;
#&lt;math&gt;\log n = O(\sqrt n)&lt;/math&gt;
#&lt;math&gt;n^2(1 + \sqrt n) = O(n^2 \log n)&lt;/math&gt;
#&lt;math&gt;3n^2 + \sqrt n = O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n \log n= O(n) &lt;/math&gt;
#&lt;math&gt;\log n=O(n^{-1/2})&lt;/math&gt;


:[[2.29]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, state whether &lt;math&gt;f(n)=O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;, or none of the above.
#&lt;math&gt;f(n)=n^2+3n+4&lt;/math&gt;, &lt;math&gt;g(n)=6n+7&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n&lt;/math&gt;, &lt;math&gt;g(n)=n^2-n&lt;/math&gt;
#&lt;math&gt;f(n)=2^n - n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^4+n^2&lt;/math&gt;

[[2.29|Solution]]. 


:2.30. For each of these questions, briefly explain your answer.
&lt;br&gt;
::(a) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
&lt;br&gt;
::(b) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
&lt;br&gt;
::(c) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
&lt;br&gt;
::(d) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
&lt;br&gt;
::(e) Is the function &lt;math&gt;f(n) = \Theta(n^2)&lt;/math&gt;, where &lt;math&gt;f(n) = 100 n^2&lt;/math&gt; for even &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;f(n) = 20 n^2 - n \log_2 n&lt;/math&gt; for odd &lt;math&gt;n&lt;/math&gt;?


:[[2.31]]. For each of the following, answer ''yes'', ''no'', or ''can't tell''. Explain your reasoning.
&lt;br&gt;
::(a) Is &lt;math&gt;3^n = O(2^n)&lt;/math&gt;?
&lt;br&gt;
::(b) Is &lt;math&gt;\log 3^n = O( \log 2^n )&lt;/math&gt;?
&lt;br&gt;
::(c) Is &lt;math&gt;3^n = \Omega(2^n)&lt;/math&gt;?
&lt;br&gt;
::(d) Is &lt;math&gt;\log 3^n = \Omega( \log 2^n )&lt;/math&gt;?

[[2.31|Solution]]


:2.32. For each of the following expressions &lt;math&gt;f(n)&lt;/math&gt; find a simple &lt;math&gt;g(n)&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n {1\over i}&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \lceil {1\over i}\rceil&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \log i&lt;/math&gt;.
#&lt;math&gt;f(n)=\log (n!)&lt;/math&gt;.


:[[2.33]]. Place the following functions into increasing asymptotic order.
::&lt;math&gt;f_1(n) = n^2\log_2n&lt;/math&gt;, &lt;math&gt;f_2(n) = n(\log_2n)^2&lt;/math&gt;, &lt;math&gt;f_3(n) = \sum_{i=0}^n 2^i&lt;/math&gt;, &lt;math&gt;f_4(n) = \log_2(\sum_{i=0}^n 2^i)&lt;/math&gt;.

[[2.33|Solution]]


:2.34. Which of the following are true?
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n-1})&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^n)&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n+1})&lt;/math&gt;.


:[[2.35]]. For each of the following functions &lt;math&gt;f&lt;/math&gt; find a simple function &lt;math&gt;g&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f_1(n)= (1000)2^n + 4^n&lt;/math&gt;.
#&lt;math&gt;f_2(n)= n + n\log n + \sqrt n&lt;/math&gt;.
#&lt;math&gt;f_3(n)= \log (n^{20}) + (\log n)^{10}&lt;/math&gt;.
#&lt;math&gt;f_4(n)= (0.99)^n + n^{100}.&lt;/math&gt;

[[2.35|Solution]]


:2.36. For each pair of expressions &lt;math&gt;(A,B)&lt;/math&gt; below, indicate whether &lt;math&gt;A&lt;/math&gt; is &lt;math&gt;O&lt;/math&gt;, &lt;math&gt;o&lt;/math&gt;, &lt;math&gt;\Omega&lt;/math&gt;, &lt;math&gt;\omega&lt;/math&gt;, or &lt;math&gt;\Theta&lt;/math&gt; of
&lt;math&gt;B&lt;/math&gt;.  Note that zero, one or more of these relations may hold for a
given pair; list all correct ones.
&lt;br&gt;&lt;center&gt;&lt;math&gt;
\begin{array}{lcc}
        &amp; A                     &amp; B \\
(a)     &amp; n^{100}               &amp; 2^n \\
(b)     &amp; (\lg n)^{12}         &amp; \sqrt{n} \\
(c)     &amp; \sqrt{n}              &amp; n^{\cos (\pi n/8)} \\
(d)     &amp; 10^n                  &amp; 100^n \\
(e)     &amp; n^{\lg n}            &amp; (\lg n)^n \\
(f)     &amp; \lg{(n!)}            &amp; n \lg n
\end{array}
&lt;/math&gt;&lt;/center&gt;

===Summations===


:[[2.37]]. Find an expression for the sum of the &lt;math&gt;i&lt;/math&gt;th row of the following triangle, and prove its correctness. Each entry is the sum of the three entries directly above it. All non existing entries are considered 0.
&lt;center&gt;
&lt;math&gt;\begin{array}{ccccccccc}
&amp;&amp;&amp;&amp;1&amp;&amp;&amp;&amp; \\
&amp;&amp;&amp;1&amp;1&amp;1&amp;&amp;&amp;\\
&amp;&amp;1&amp;2&amp;3&amp;2&amp;1&amp;&amp;\\
&amp;1&amp;3&amp;6&amp;7&amp;6&amp;3&amp;1&amp;\\
1&amp;4&amp;10&amp;16&amp;19&amp;16&amp;10&amp;4&amp;1\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.37|Solution]]


:2.38. Assume that Christmas has &lt;math&gt;n&lt;/math&gt; days. Exactly how many presents did my ''true love'' send me? (Do some research if you do not understand this question.)


:[[2.39]]

[[2.39|Solution]]


:2.40. Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n do
      for j=i to 2*i do
         output ''foobar''
&lt;/tt&gt;
:Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as a summation (actually two nested summations).
#Simplify the summation.  Show your work.


:[[2.41]].Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n/2 do
      for j=i to n-i do
         for k=1 to j do
            output ''foobar''
&lt;/tt&gt;
:Assume &lt;math&gt;n&lt;/math&gt; is even. Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as three nested summations.
#Simplify the summation.  Show your work.

[[2.41|Solution]]


:2.42. When you first learned to multiply numbers, you were told that &lt;math&gt;x \times y&lt;/math&gt; means adding &lt;math&gt;x&lt;/math&gt; a total of &lt;math&gt;y&lt;/math&gt; times, so &lt;math&gt;5 \times 4 = 5+5+5+5 = 20&lt;/math&gt;. What is the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers in base &lt;math&gt;b&lt;/math&gt; (people work in base 10, of course, while computers work in base 2) using the repeated addition method, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;. Assume that single-digit by single-digit addition or multiplication takes
&lt;math&gt;O(1)&lt;/math&gt; time. (Hint: how big can &lt;math&gt;y&lt;/math&gt; be as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;?)


:[[2.43]]. In grade school, you learned to multiply long numbers on a digit-by-digit basis, so that &lt;math&gt;127 \times 211 = 127 \times 1 + 127 \times 10 + 127 \times 200 = 26,397&lt;/math&gt;. Analyze the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers with this method as a function of &lt;math&gt;n&lt;/math&gt; (assume constant base size). Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time.

[2.43|Solution]]

===Logartihms===


:2.44

:2.45

:2.46

:2.47

===Interview Problems===


:2.48

:2.49

:2.50

:2.51

:2.52

:2.53

:2.54

:2.55


Back to [[Chapter List]]</text>
      <sha1>tw7dsqqn5bw196wuvnymgxewz3lrexx</sha1>
    </revision>
    <revision>
      <id>94</id>
      <parentid>93</parentid>
      <timestamp>2020-09-07T16:56:53Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Big Oh */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="14571">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
       ''return''(r)


:[[2.5]]. Consider the following algorithm: (the print operation prints a single asterisk; the operation &lt;math&gt;x = 2x&lt;/math&gt; doubles the value of the variable &lt;math&gt;x&lt;/math&gt;).
    ''for'' &lt;math&gt; k = 1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt;
        &lt;math&gt;x = k&lt;/math&gt;
        ''while'' (&lt;math&gt;x &lt; n&lt;/math&gt;):
           ''print'' '*'
           &lt;math&gt;x = 2x&lt;/math&gt;
:Let &lt;math&gt;f(n)&lt;/math&gt; be the complexity of this algorithm (or equivalently the number of times * is printed). Proivde correct bounds for &lt;math&gt; O(f(n))&lt;/math&gt;, and &lt;math&gt;/Theta(f(n))&lt;/math&gt;, ideally converging on &lt;math&gt;\Theta(f(n))&lt;/math&gt;.

[[2.5|Solution]]


:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. True or False?
#Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.9|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]. For each of the following functions, which of the following asymptotic bounds hold for &lt;math&gt;f(n) = O(g(n)),\Theta(g(n)),\Omega(g(n))&lt;/math&gt;?

[[2.11|Solution]]


:2.12. Prove that &lt;math&gt;n^3 - 3n^2-n+1 = \Theta(n^3)&lt;/math&gt;.


:2.13. Prove that &lt;math&gt;n^2 = O(2^n)&lt;/math&gt;.

[[2.13|Solution]]


:2.14. Prove or disprove: &lt;math&gt;\Theta(n^2) = \Theta(n^2+1)&lt;/math&gt;.


:[[2.15]]. Suppose you have algorithms with the five running times listed below. (Assume these are the exact running times.) How much slower do each of these inputs get when you (a) double the input size, or (b) increase the input size by one?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;

[[2.15|Solution]]


:2.16.  Suppose you have algorithms with the six running times listed below. (Assume these are the exact number of operations performed as a function of input size &lt;math&gt;n&lt;/math&gt;.)Suppose you have a computer that can perform &lt;math&gt;10^10&lt;/math&gt; operations per second. For each algorithm, what is the largest input size n that you can complete within an hour?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;  (f) &lt;math&gt;2^{2^n}&lt;/math&gt;


:[[2.17]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, give an appropriate positive constant &lt;math&gt;c&lt;/math&gt; such that &lt;math&gt;f(n) \leq c \cdot g(n)&lt;/math&gt; for all &lt;math&gt;n &gt; 1&lt;/math&gt;.
#&lt;math&gt;f(n)=n^2+n+1&lt;/math&gt;, &lt;math&gt;g(n)=2n^3&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n + n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^2&lt;/math&gt;
#&lt;math&gt;f(n)=n^2-n+1&lt;/math&gt;, &lt;math&gt;g(n)=n^2/2&lt;/math&gt;

[[2.17|Solution]]


:2.18. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n) = O(g_1(n)+g_2(n))&lt;/math&gt;.


:[[2.19]]. Prove that if &lt;math&gt;f_1(N)=\Omega(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=\Omega(g_2(n) &lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n)=\Omega(g_1(n)+g_2(n))&lt;/math&gt;.

[[2.19|Solution]]


:2.20. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n) \cdot f_2(n) = O(g_1(n) \cdot g_2(n))&lt;/math&gt;


:[[2.21]]. Prove for all &lt;math&gt;k \geq 1&lt;/math&gt; and all sets of constants &lt;math&gt;\{a_k, a_{k-1}, \ldots, a_1,a_0\} \in R&lt;/math&gt;, &lt;math&gt; a_k n^k + a_{k-1}n^{k-1}+....+a_1 n + a_0 = O(n^k)&lt;/math&gt;

[[2.21|Solution]]


:2.22. Show that for any real constants &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;, &lt;math&gt;b &gt; 0&lt;/math&gt;
&lt;center&gt;&lt;math&gt;(n + a)^b = \Omega (n^b)&lt;/math&gt;&lt;/center&gt;


:[[2.23]]. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{llll}
n &amp; 2^n &amp; n \lg n &amp; \ln n \\
n-n^3+7n^5 &amp; \lg n &amp; \sqrt n &amp; e^n \\
n^2+\lg n &amp; n^2 &amp; 2^{n-1} &amp;  \lg \lg n \\
n^3 &amp; (\lg n)^2 &amp; n! &amp; n^{1+\varepsilon} where 0&lt; \varepsilon &lt;1
\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.23|Solution]]


:2.24


:[[2.25]]

[[2.25|Solution]]


:2.26. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{lll}
\sqrt{n} &amp; n &amp; 2^n \\
n \log n &amp;  n - n^3 + 7n^5 &amp;  n^2 + \log n \\
n^2 &amp;  n^3 &amp;  \log n \\
n^{\frac{1}{3}} + \log n &amp; (\log n)^2 &amp;  n! \\
\ln n &amp; \frac{n}{\log n} &amp;  \log \log n \\
({1}/{3})^n &amp;  ({3}/{2})^n &amp;  6 \\
\end{array}&lt;/math&gt;
&lt;/center&gt;


:[[2.27]]. Find two functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt; that satisfy the following relationship. If no such &lt;math&gt;f&lt;/math&gt; and &lt;math&gt;g&lt;/math&gt; exist, write ''None.''
#&lt;math&gt;f(n)=o(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq \Theta(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n)=o(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;

[[2.27|Solution]]


:2.28. True or False?
#&lt;math&gt;2n^2+1=O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n= O(\log n)&lt;/math&gt;
#&lt;math&gt;\log n = O(\sqrt n)&lt;/math&gt;
#&lt;math&gt;n^2(1 + \sqrt n) = O(n^2 \log n)&lt;/math&gt;
#&lt;math&gt;3n^2 + \sqrt n = O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n \log n= O(n) &lt;/math&gt;
#&lt;math&gt;\log n=O(n^{-1/2})&lt;/math&gt;


:[[2.29]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, state whether &lt;math&gt;f(n)=O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;, or none of the above.
#&lt;math&gt;f(n)=n^2+3n+4&lt;/math&gt;, &lt;math&gt;g(n)=6n+7&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n&lt;/math&gt;, &lt;math&gt;g(n)=n^2-n&lt;/math&gt;
#&lt;math&gt;f(n)=2^n - n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^4+n^2&lt;/math&gt;

[[2.29|Solution]]. 


:2.30. For each of these questions, briefly explain your answer.
&lt;br&gt;
::(a) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
&lt;br&gt;
::(b) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
&lt;br&gt;
::(c) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
&lt;br&gt;
::(d) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
&lt;br&gt;
::(e) Is the function &lt;math&gt;f(n) = \Theta(n^2)&lt;/math&gt;, where &lt;math&gt;f(n) = 100 n^2&lt;/math&gt; for even &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;f(n) = 20 n^2 - n \log_2 n&lt;/math&gt; for odd &lt;math&gt;n&lt;/math&gt;?


:[[2.31]]. For each of the following, answer ''yes'', ''no'', or ''can't tell''. Explain your reasoning.
&lt;br&gt;
::(a) Is &lt;math&gt;3^n = O(2^n)&lt;/math&gt;?
&lt;br&gt;
::(b) Is &lt;math&gt;\log 3^n = O( \log 2^n )&lt;/math&gt;?
&lt;br&gt;
::(c) Is &lt;math&gt;3^n = \Omega(2^n)&lt;/math&gt;?
&lt;br&gt;
::(d) Is &lt;math&gt;\log 3^n = \Omega( \log 2^n )&lt;/math&gt;?

[[2.31|Solution]]


:2.32. For each of the following expressions &lt;math&gt;f(n)&lt;/math&gt; find a simple &lt;math&gt;g(n)&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n {1\over i}&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \lceil {1\over i}\rceil&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \log i&lt;/math&gt;.
#&lt;math&gt;f(n)=\log (n!)&lt;/math&gt;.


:[[2.33]]. Place the following functions into increasing asymptotic order.
::&lt;math&gt;f_1(n) = n^2\log_2n&lt;/math&gt;, &lt;math&gt;f_2(n) = n(\log_2n)^2&lt;/math&gt;, &lt;math&gt;f_3(n) = \sum_{i=0}^n 2^i&lt;/math&gt;, &lt;math&gt;f_4(n) = \log_2(\sum_{i=0}^n 2^i)&lt;/math&gt;.

[[2.33|Solution]]


:2.34. Which of the following are true?
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n-1})&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^n)&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n+1})&lt;/math&gt;.


:[[2.35]]. For each of the following functions &lt;math&gt;f&lt;/math&gt; find a simple function &lt;math&gt;g&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f_1(n)= (1000)2^n + 4^n&lt;/math&gt;.
#&lt;math&gt;f_2(n)= n + n\log n + \sqrt n&lt;/math&gt;.
#&lt;math&gt;f_3(n)= \log (n^{20}) + (\log n)^{10}&lt;/math&gt;.
#&lt;math&gt;f_4(n)= (0.99)^n + n^{100}.&lt;/math&gt;

[[2.35|Solution]]


:2.36. For each pair of expressions &lt;math&gt;(A,B)&lt;/math&gt; below, indicate whether &lt;math&gt;A&lt;/math&gt; is &lt;math&gt;O&lt;/math&gt;, &lt;math&gt;o&lt;/math&gt;, &lt;math&gt;\Omega&lt;/math&gt;, &lt;math&gt;\omega&lt;/math&gt;, or &lt;math&gt;\Theta&lt;/math&gt; of &lt;math&gt;B&lt;/math&gt;.  Note that zero, one or more of these relations may hold for a given pair; list all correct ones.
&lt;br&gt;&lt;center&gt;&lt;math&gt;
\begin{array}{lcc}
        &amp; A                     &amp; B \\
(a)     &amp; n^{100}               &amp; 2^n \\
(b)     &amp; (\lg n)^{12}         &amp; \sqrt{n} \\
(c)     &amp; \sqrt{n}              &amp; n^{\cos (\pi n/8)} \\
(d)     &amp; 10^n                  &amp; 100^n \\
(e)     &amp; n^{\lg n}            &amp; (\lg n)^n \\
(f)     &amp; \lg{(n!)}            &amp; n \lg n
\end{array}
&lt;/math&gt;&lt;/center&gt;

===Summations===


:[[2.37]]. Find an expression for the sum of the &lt;math&gt;i&lt;/math&gt;th row of the following triangle, and prove its correctness. Each entry is the sum of the three entries directly above it. All non existing entries are considered 0.
&lt;center&gt;
&lt;math&gt;\begin{array}{ccccccccc}
&amp;&amp;&amp;&amp;1&amp;&amp;&amp;&amp; \\
&amp;&amp;&amp;1&amp;1&amp;1&amp;&amp;&amp;\\
&amp;&amp;1&amp;2&amp;3&amp;2&amp;1&amp;&amp;\\
&amp;1&amp;3&amp;6&amp;7&amp;6&amp;3&amp;1&amp;\\
1&amp;4&amp;10&amp;16&amp;19&amp;16&amp;10&amp;4&amp;1\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.37|Solution]]


:2.38. Assume that Christmas has &lt;math&gt;n&lt;/math&gt; days. Exactly how many presents did my ''true love'' send me? (Do some research if you do not understand this question.)


:[[2.39]]

[[2.39|Solution]]


:2.40. Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n do
      for j=i to 2*i do
         output ''foobar''
&lt;/tt&gt;
:Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as a summation (actually two nested summations).
#Simplify the summation.  Show your work.


:[[2.41]].Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n/2 do
      for j=i to n-i do
         for k=1 to j do
            output ''foobar''
&lt;/tt&gt;
:Assume &lt;math&gt;n&lt;/math&gt; is even. Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as three nested summations.
#Simplify the summation.  Show your work.

[[2.41|Solution]]


:2.42. When you first learned to multiply numbers, you were told that &lt;math&gt;x \times y&lt;/math&gt; means adding &lt;math&gt;x&lt;/math&gt; a total of &lt;math&gt;y&lt;/math&gt; times, so &lt;math&gt;5 \times 4 = 5+5+5+5 = 20&lt;/math&gt;. What is the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers in base &lt;math&gt;b&lt;/math&gt; (people work in base 10, of course, while computers work in base 2) using the repeated addition method, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;. Assume that single-digit by single-digit addition or multiplication takes
&lt;math&gt;O(1)&lt;/math&gt; time. (Hint: how big can &lt;math&gt;y&lt;/math&gt; be as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;?)


:[[2.43]]. In grade school, you learned to multiply long numbers on a digit-by-digit basis, so that &lt;math&gt;127 \times 211 = 127 \times 1 + 127 \times 10 + 127 \times 200 = 26,397&lt;/math&gt;. Analyze the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers with this method as a function of &lt;math&gt;n&lt;/math&gt; (assume constant base size). Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time.

[2.43|Solution]]

===Logartihms===


:2.44

:2.45

:2.46

:2.47

===Interview Problems===


:2.48

:2.49

:2.50

:2.51

:2.52

:2.53

:2.54

:2.55


Back to [[Chapter List]]</text>
      <sha1>8op43ghwsvbfvej5agx85iuj9av85fv</sha1>
    </revision>
    <revision>
      <id>95</id>
      <parentid>94</parentid>
      <timestamp>2020-09-07T16:57:44Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Summations */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="14572">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
       ''return''(r)


:[[2.5]]. Consider the following algorithm: (the print operation prints a single asterisk; the operation &lt;math&gt;x = 2x&lt;/math&gt; doubles the value of the variable &lt;math&gt;x&lt;/math&gt;).
    ''for'' &lt;math&gt; k = 1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt;
        &lt;math&gt;x = k&lt;/math&gt;
        ''while'' (&lt;math&gt;x &lt; n&lt;/math&gt;):
           ''print'' '*'
           &lt;math&gt;x = 2x&lt;/math&gt;
:Let &lt;math&gt;f(n)&lt;/math&gt; be the complexity of this algorithm (or equivalently the number of times * is printed). Proivde correct bounds for &lt;math&gt; O(f(n))&lt;/math&gt;, and &lt;math&gt;/Theta(f(n))&lt;/math&gt;, ideally converging on &lt;math&gt;\Theta(f(n))&lt;/math&gt;.

[[2.5|Solution]]


:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. True or False?
#Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.9|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]. For each of the following functions, which of the following asymptotic bounds hold for &lt;math&gt;f(n) = O(g(n)),\Theta(g(n)),\Omega(g(n))&lt;/math&gt;?

[[2.11|Solution]]


:2.12. Prove that &lt;math&gt;n^3 - 3n^2-n+1 = \Theta(n^3)&lt;/math&gt;.


:2.13. Prove that &lt;math&gt;n^2 = O(2^n)&lt;/math&gt;.

[[2.13|Solution]]


:2.14. Prove or disprove: &lt;math&gt;\Theta(n^2) = \Theta(n^2+1)&lt;/math&gt;.


:[[2.15]]. Suppose you have algorithms with the five running times listed below. (Assume these are the exact running times.) How much slower do each of these inputs get when you (a) double the input size, or (b) increase the input size by one?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;

[[2.15|Solution]]


:2.16.  Suppose you have algorithms with the six running times listed below. (Assume these are the exact number of operations performed as a function of input size &lt;math&gt;n&lt;/math&gt;.)Suppose you have a computer that can perform &lt;math&gt;10^10&lt;/math&gt; operations per second. For each algorithm, what is the largest input size n that you can complete within an hour?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;  (f) &lt;math&gt;2^{2^n}&lt;/math&gt;


:[[2.17]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, give an appropriate positive constant &lt;math&gt;c&lt;/math&gt; such that &lt;math&gt;f(n) \leq c \cdot g(n)&lt;/math&gt; for all &lt;math&gt;n &gt; 1&lt;/math&gt;.
#&lt;math&gt;f(n)=n^2+n+1&lt;/math&gt;, &lt;math&gt;g(n)=2n^3&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n + n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^2&lt;/math&gt;
#&lt;math&gt;f(n)=n^2-n+1&lt;/math&gt;, &lt;math&gt;g(n)=n^2/2&lt;/math&gt;

[[2.17|Solution]]


:2.18. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n) = O(g_1(n)+g_2(n))&lt;/math&gt;.


:[[2.19]]. Prove that if &lt;math&gt;f_1(N)=\Omega(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=\Omega(g_2(n) &lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n)=\Omega(g_1(n)+g_2(n))&lt;/math&gt;.

[[2.19|Solution]]


:2.20. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n) \cdot f_2(n) = O(g_1(n) \cdot g_2(n))&lt;/math&gt;


:[[2.21]]. Prove for all &lt;math&gt;k \geq 1&lt;/math&gt; and all sets of constants &lt;math&gt;\{a_k, a_{k-1}, \ldots, a_1,a_0\} \in R&lt;/math&gt;, &lt;math&gt; a_k n^k + a_{k-1}n^{k-1}+....+a_1 n + a_0 = O(n^k)&lt;/math&gt;

[[2.21|Solution]]


:2.22. Show that for any real constants &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;, &lt;math&gt;b &gt; 0&lt;/math&gt;
&lt;center&gt;&lt;math&gt;(n + a)^b = \Omega (n^b)&lt;/math&gt;&lt;/center&gt;


:[[2.23]]. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{llll}
n &amp; 2^n &amp; n \lg n &amp; \ln n \\
n-n^3+7n^5 &amp; \lg n &amp; \sqrt n &amp; e^n \\
n^2+\lg n &amp; n^2 &amp; 2^{n-1} &amp;  \lg \lg n \\
n^3 &amp; (\lg n)^2 &amp; n! &amp; n^{1+\varepsilon} where 0&lt; \varepsilon &lt;1
\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.23|Solution]]


:2.24


:[[2.25]]

[[2.25|Solution]]


:2.26. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{lll}
\sqrt{n} &amp; n &amp; 2^n \\
n \log n &amp;  n - n^3 + 7n^5 &amp;  n^2 + \log n \\
n^2 &amp;  n^3 &amp;  \log n \\
n^{\frac{1}{3}} + \log n &amp; (\log n)^2 &amp;  n! \\
\ln n &amp; \frac{n}{\log n} &amp;  \log \log n \\
({1}/{3})^n &amp;  ({3}/{2})^n &amp;  6 \\
\end{array}&lt;/math&gt;
&lt;/center&gt;


:[[2.27]]. Find two functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt; that satisfy the following relationship. If no such &lt;math&gt;f&lt;/math&gt; and &lt;math&gt;g&lt;/math&gt; exist, write ''None.''
#&lt;math&gt;f(n)=o(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq \Theta(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n)=o(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;

[[2.27|Solution]]


:2.28. True or False?
#&lt;math&gt;2n^2+1=O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n= O(\log n)&lt;/math&gt;
#&lt;math&gt;\log n = O(\sqrt n)&lt;/math&gt;
#&lt;math&gt;n^2(1 + \sqrt n) = O(n^2 \log n)&lt;/math&gt;
#&lt;math&gt;3n^2 + \sqrt n = O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n \log n= O(n) &lt;/math&gt;
#&lt;math&gt;\log n=O(n^{-1/2})&lt;/math&gt;


:[[2.29]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, state whether &lt;math&gt;f(n)=O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;, or none of the above.
#&lt;math&gt;f(n)=n^2+3n+4&lt;/math&gt;, &lt;math&gt;g(n)=6n+7&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n&lt;/math&gt;, &lt;math&gt;g(n)=n^2-n&lt;/math&gt;
#&lt;math&gt;f(n)=2^n - n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^4+n^2&lt;/math&gt;

[[2.29|Solution]]. 


:2.30. For each of these questions, briefly explain your answer.
&lt;br&gt;
::(a) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
&lt;br&gt;
::(b) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
&lt;br&gt;
::(c) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
&lt;br&gt;
::(d) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
&lt;br&gt;
::(e) Is the function &lt;math&gt;f(n) = \Theta(n^2)&lt;/math&gt;, where &lt;math&gt;f(n) = 100 n^2&lt;/math&gt; for even &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;f(n) = 20 n^2 - n \log_2 n&lt;/math&gt; for odd &lt;math&gt;n&lt;/math&gt;?


:[[2.31]]. For each of the following, answer ''yes'', ''no'', or ''can't tell''. Explain your reasoning.
&lt;br&gt;
::(a) Is &lt;math&gt;3^n = O(2^n)&lt;/math&gt;?
&lt;br&gt;
::(b) Is &lt;math&gt;\log 3^n = O( \log 2^n )&lt;/math&gt;?
&lt;br&gt;
::(c) Is &lt;math&gt;3^n = \Omega(2^n)&lt;/math&gt;?
&lt;br&gt;
::(d) Is &lt;math&gt;\log 3^n = \Omega( \log 2^n )&lt;/math&gt;?

[[2.31|Solution]]


:2.32. For each of the following expressions &lt;math&gt;f(n)&lt;/math&gt; find a simple &lt;math&gt;g(n)&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n {1\over i}&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \lceil {1\over i}\rceil&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \log i&lt;/math&gt;.
#&lt;math&gt;f(n)=\log (n!)&lt;/math&gt;.


:[[2.33]]. Place the following functions into increasing asymptotic order.
::&lt;math&gt;f_1(n) = n^2\log_2n&lt;/math&gt;, &lt;math&gt;f_2(n) = n(\log_2n)^2&lt;/math&gt;, &lt;math&gt;f_3(n) = \sum_{i=0}^n 2^i&lt;/math&gt;, &lt;math&gt;f_4(n) = \log_2(\sum_{i=0}^n 2^i)&lt;/math&gt;.

[[2.33|Solution]]


:2.34. Which of the following are true?
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n-1})&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^n)&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n+1})&lt;/math&gt;.


:[[2.35]]. For each of the following functions &lt;math&gt;f&lt;/math&gt; find a simple function &lt;math&gt;g&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f_1(n)= (1000)2^n + 4^n&lt;/math&gt;.
#&lt;math&gt;f_2(n)= n + n\log n + \sqrt n&lt;/math&gt;.
#&lt;math&gt;f_3(n)= \log (n^{20}) + (\log n)^{10}&lt;/math&gt;.
#&lt;math&gt;f_4(n)= (0.99)^n + n^{100}.&lt;/math&gt;

[[2.35|Solution]]


:2.36. For each pair of expressions &lt;math&gt;(A,B)&lt;/math&gt; below, indicate whether &lt;math&gt;A&lt;/math&gt; is &lt;math&gt;O&lt;/math&gt;, &lt;math&gt;o&lt;/math&gt;, &lt;math&gt;\Omega&lt;/math&gt;, &lt;math&gt;\omega&lt;/math&gt;, or &lt;math&gt;\Theta&lt;/math&gt; of &lt;math&gt;B&lt;/math&gt;.  Note that zero, one or more of these relations may hold for a given pair; list all correct ones.
&lt;br&gt;&lt;center&gt;&lt;math&gt;
\begin{array}{lcc}
        &amp; A                     &amp; B \\
(a)     &amp; n^{100}               &amp; 2^n \\
(b)     &amp; (\lg n)^{12}         &amp; \sqrt{n} \\
(c)     &amp; \sqrt{n}              &amp; n^{\cos (\pi n/8)} \\
(d)     &amp; 10^n                  &amp; 100^n \\
(e)     &amp; n^{\lg n}            &amp; (\lg n)^n \\
(f)     &amp; \lg{(n!)}            &amp; n \lg n
\end{array}
&lt;/math&gt;&lt;/center&gt;

===Summations===


:[[2.37]]. Find an expression for the sum of the &lt;math&gt;i&lt;/math&gt;th row of the following triangle, and prove its correctness. Each entry is the sum of the three entries directly above it. All non existing entries are considered 0.
&lt;center&gt;
&lt;math&gt;\begin{array}{ccccccccc}
&amp;&amp;&amp;&amp;1&amp;&amp;&amp;&amp; \\
&amp;&amp;&amp;1&amp;1&amp;1&amp;&amp;&amp;\\
&amp;&amp;1&amp;2&amp;3&amp;2&amp;1&amp;&amp;\\
&amp;1&amp;3&amp;6&amp;7&amp;6&amp;3&amp;1&amp;\\
1&amp;4&amp;10&amp;16&amp;19&amp;16&amp;10&amp;4&amp;1\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.37|Solution]]


:2.38. Assume that Christmas has &lt;math&gt;n&lt;/math&gt; days. Exactly how many presents did my ''true love'' send me? (Do some research if you do not understand this question.)


:[[2.39]]

[[2.39|Solution]]


:2.40. Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n do
      for j=i to 2*i do
         output ''foobar''
&lt;/tt&gt;
:Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as a summation (actually two nested summations).
#Simplify the summation.  Show your work.


:[[2.41]].Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n/2 do
      for j=i to n-i do
         for k=1 to j do
            output ''foobar''
&lt;/tt&gt;
:Assume &lt;math&gt;n&lt;/math&gt; is even. Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as three nested summations.
#Simplify the summation.  Show your work.

[[2.41|Solution]]


:2.42. When you first learned to multiply numbers, you were told that &lt;math&gt;x \times y&lt;/math&gt; means adding &lt;math&gt;x&lt;/math&gt; a total of &lt;math&gt;y&lt;/math&gt; times, so &lt;math&gt;5 \times 4 = 5+5+5+5 = 20&lt;/math&gt;. What is the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers in base &lt;math&gt;b&lt;/math&gt; (people work in base 10, of course, while computers work in base 2) using the repeated addition method, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;. Assume that single-digit by single-digit addition or multiplication takes
&lt;math&gt;O(1)&lt;/math&gt; time. (Hint: how big can &lt;math&gt;y&lt;/math&gt; be as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;?)


:[[2.43]]. In grade school, you learned to multiply long numbers on a digit-by-digit basis, so that &lt;math&gt;127 \times 211 = 127 \times 1 + 127 \times 10 + 127 \times 200 = 26,397&lt;/math&gt;. Analyze the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers with this method as a function of &lt;math&gt;n&lt;/math&gt; (assume constant base size). Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time.

[[2.43|Solution]]

===Logartihms===


:2.44

:2.45

:2.46

:2.47

===Interview Problems===


:2.48

:2.49

:2.50

:2.51

:2.52

:2.53

:2.54

:2.55


Back to [[Chapter List]]</text>
      <sha1>5ak8214hgedwuncqpaoem8z8cffz493</sha1>
    </revision>
    <revision>
      <id>96</id>
      <parentid>95</parentid>
      <timestamp>2020-09-07T16:58:27Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Summations */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="14572">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
       ''return''(r)


:[[2.5]]. Consider the following algorithm: (the print operation prints a single asterisk; the operation &lt;math&gt;x = 2x&lt;/math&gt; doubles the value of the variable &lt;math&gt;x&lt;/math&gt;).
    ''for'' &lt;math&gt; k = 1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt;
        &lt;math&gt;x = k&lt;/math&gt;
        ''while'' (&lt;math&gt;x &lt; n&lt;/math&gt;):
           ''print'' '*'
           &lt;math&gt;x = 2x&lt;/math&gt;
:Let &lt;math&gt;f(n)&lt;/math&gt; be the complexity of this algorithm (or equivalently the number of times * is printed). Proivde correct bounds for &lt;math&gt; O(f(n))&lt;/math&gt;, and &lt;math&gt;/Theta(f(n))&lt;/math&gt;, ideally converging on &lt;math&gt;\Theta(f(n))&lt;/math&gt;.

[[2.5|Solution]]


:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. True or False?
#Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.9|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]. For each of the following functions, which of the following asymptotic bounds hold for &lt;math&gt;f(n) = O(g(n)),\Theta(g(n)),\Omega(g(n))&lt;/math&gt;?

[[2.11|Solution]]


:2.12. Prove that &lt;math&gt;n^3 - 3n^2-n+1 = \Theta(n^3)&lt;/math&gt;.


:2.13. Prove that &lt;math&gt;n^2 = O(2^n)&lt;/math&gt;.

[[2.13|Solution]]


:2.14. Prove or disprove: &lt;math&gt;\Theta(n^2) = \Theta(n^2+1)&lt;/math&gt;.


:[[2.15]]. Suppose you have algorithms with the five running times listed below. (Assume these are the exact running times.) How much slower do each of these inputs get when you (a) double the input size, or (b) increase the input size by one?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;

[[2.15|Solution]]


:2.16.  Suppose you have algorithms with the six running times listed below. (Assume these are the exact number of operations performed as a function of input size &lt;math&gt;n&lt;/math&gt;.)Suppose you have a computer that can perform &lt;math&gt;10^10&lt;/math&gt; operations per second. For each algorithm, what is the largest input size n that you can complete within an hour?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;  (f) &lt;math&gt;2^{2^n}&lt;/math&gt;


:[[2.17]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, give an appropriate positive constant &lt;math&gt;c&lt;/math&gt; such that &lt;math&gt;f(n) \leq c \cdot g(n)&lt;/math&gt; for all &lt;math&gt;n &gt; 1&lt;/math&gt;.
#&lt;math&gt;f(n)=n^2+n+1&lt;/math&gt;, &lt;math&gt;g(n)=2n^3&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n + n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^2&lt;/math&gt;
#&lt;math&gt;f(n)=n^2-n+1&lt;/math&gt;, &lt;math&gt;g(n)=n^2/2&lt;/math&gt;

[[2.17|Solution]]


:2.18. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n) = O(g_1(n)+g_2(n))&lt;/math&gt;.


:[[2.19]]. Prove that if &lt;math&gt;f_1(N)=\Omega(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=\Omega(g_2(n) &lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n)=\Omega(g_1(n)+g_2(n))&lt;/math&gt;.

[[2.19|Solution]]


:2.20. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n) \cdot f_2(n) = O(g_1(n) \cdot g_2(n))&lt;/math&gt;


:[[2.21]]. Prove for all &lt;math&gt;k \geq 1&lt;/math&gt; and all sets of constants &lt;math&gt;\{a_k, a_{k-1}, \ldots, a_1,a_0\} \in R&lt;/math&gt;, &lt;math&gt; a_k n^k + a_{k-1}n^{k-1}+....+a_1 n + a_0 = O(n^k)&lt;/math&gt;

[[2.21|Solution]]


:2.22. Show that for any real constants &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;, &lt;math&gt;b &gt; 0&lt;/math&gt;
&lt;center&gt;&lt;math&gt;(n + a)^b = \Omega (n^b)&lt;/math&gt;&lt;/center&gt;


:[[2.23]]. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{llll}
n &amp; 2^n &amp; n \lg n &amp; \ln n \\
n-n^3+7n^5 &amp; \lg n &amp; \sqrt n &amp; e^n \\
n^2+\lg n &amp; n^2 &amp; 2^{n-1} &amp;  \lg \lg n \\
n^3 &amp; (\lg n)^2 &amp; n! &amp; n^{1+\varepsilon} where 0&lt; \varepsilon &lt;1
\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.23|Solution]]


:2.24


:[[2.25]]

[[2.25|Solution]]


:2.26. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{lll}
\sqrt{n} &amp; n &amp; 2^n \\
n \log n &amp;  n - n^3 + 7n^5 &amp;  n^2 + \log n \\
n^2 &amp;  n^3 &amp;  \log n \\
n^{\frac{1}{3}} + \log n &amp; (\log n)^2 &amp;  n! \\
\ln n &amp; \frac{n}{\log n} &amp;  \log \log n \\
({1}/{3})^n &amp;  ({3}/{2})^n &amp;  6 \\
\end{array}&lt;/math&gt;
&lt;/center&gt;


:[[2.27]]. Find two functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt; that satisfy the following relationship. If no such &lt;math&gt;f&lt;/math&gt; and &lt;math&gt;g&lt;/math&gt; exist, write ''None.''
#&lt;math&gt;f(n)=o(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq \Theta(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n)=o(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;

[[2.27|Solution]]


:2.28. True or False?
#&lt;math&gt;2n^2+1=O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n= O(\log n)&lt;/math&gt;
#&lt;math&gt;\log n = O(\sqrt n)&lt;/math&gt;
#&lt;math&gt;n^2(1 + \sqrt n) = O(n^2 \log n)&lt;/math&gt;
#&lt;math&gt;3n^2 + \sqrt n = O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n \log n= O(n) &lt;/math&gt;
#&lt;math&gt;\log n=O(n^{-1/2})&lt;/math&gt;


:[[2.29]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, state whether &lt;math&gt;f(n)=O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;, or none of the above.
#&lt;math&gt;f(n)=n^2+3n+4&lt;/math&gt;, &lt;math&gt;g(n)=6n+7&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n&lt;/math&gt;, &lt;math&gt;g(n)=n^2-n&lt;/math&gt;
#&lt;math&gt;f(n)=2^n - n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^4+n^2&lt;/math&gt;

[[2.29|Solution]]. 


:2.30. For each of these questions, briefly explain your answer.
&lt;br&gt;
::(a) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
&lt;br&gt;
::(b) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
&lt;br&gt;
::(c) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
&lt;br&gt;
::(d) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
&lt;br&gt;
::(e) Is the function &lt;math&gt;f(n) = \Theta(n^2)&lt;/math&gt;, where &lt;math&gt;f(n) = 100 n^2&lt;/math&gt; for even &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;f(n) = 20 n^2 - n \log_2 n&lt;/math&gt; for odd &lt;math&gt;n&lt;/math&gt;?


:[[2.31]]. For each of the following, answer ''yes'', ''no'', or ''can't tell''. Explain your reasoning.
&lt;br&gt;
::(a) Is &lt;math&gt;3^n = O(2^n)&lt;/math&gt;?
&lt;br&gt;
::(b) Is &lt;math&gt;\log 3^n = O( \log 2^n )&lt;/math&gt;?
&lt;br&gt;
::(c) Is &lt;math&gt;3^n = \Omega(2^n)&lt;/math&gt;?
&lt;br&gt;
::(d) Is &lt;math&gt;\log 3^n = \Omega( \log 2^n )&lt;/math&gt;?

[[2.31|Solution]]


:2.32. For each of the following expressions &lt;math&gt;f(n)&lt;/math&gt; find a simple &lt;math&gt;g(n)&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n {1\over i}&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \lceil {1\over i}\rceil&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \log i&lt;/math&gt;.
#&lt;math&gt;f(n)=\log (n!)&lt;/math&gt;.


:[[2.33]]. Place the following functions into increasing asymptotic order.
::&lt;math&gt;f_1(n) = n^2\log_2n&lt;/math&gt;, &lt;math&gt;f_2(n) = n(\log_2n)^2&lt;/math&gt;, &lt;math&gt;f_3(n) = \sum_{i=0}^n 2^i&lt;/math&gt;, &lt;math&gt;f_4(n) = \log_2(\sum_{i=0}^n 2^i)&lt;/math&gt;.

[[2.33|Solution]]


:2.34. Which of the following are true?
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n-1})&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^n)&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n+1})&lt;/math&gt;.


:[[2.35]]. For each of the following functions &lt;math&gt;f&lt;/math&gt; find a simple function &lt;math&gt;g&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f_1(n)= (1000)2^n + 4^n&lt;/math&gt;.
#&lt;math&gt;f_2(n)= n + n\log n + \sqrt n&lt;/math&gt;.
#&lt;math&gt;f_3(n)= \log (n^{20}) + (\log n)^{10}&lt;/math&gt;.
#&lt;math&gt;f_4(n)= (0.99)^n + n^{100}.&lt;/math&gt;

[[2.35|Solution]]


:2.36. For each pair of expressions &lt;math&gt;(A,B)&lt;/math&gt; below, indicate whether &lt;math&gt;A&lt;/math&gt; is &lt;math&gt;O&lt;/math&gt;, &lt;math&gt;o&lt;/math&gt;, &lt;math&gt;\Omega&lt;/math&gt;, &lt;math&gt;\omega&lt;/math&gt;, or &lt;math&gt;\Theta&lt;/math&gt; of &lt;math&gt;B&lt;/math&gt;.  Note that zero, one or more of these relations may hold for a given pair; list all correct ones.
&lt;br&gt;&lt;center&gt;&lt;math&gt;
\begin{array}{lcc}
        &amp; A                     &amp; B \\
(a)     &amp; n^{100}               &amp; 2^n \\
(b)     &amp; (\lg n)^{12}         &amp; \sqrt{n} \\
(c)     &amp; \sqrt{n}              &amp; n^{\cos (\pi n/8)} \\
(d)     &amp; 10^n                  &amp; 100^n \\
(e)     &amp; n^{\lg n}            &amp; (\lg n)^n \\
(f)     &amp; \lg{(n!)}            &amp; n \lg n
\end{array}
&lt;/math&gt;&lt;/center&gt;

===Summations===


:[[2.37]]. Find an expression for the sum of the &lt;math&gt;i&lt;/math&gt;th row of the following triangle, and prove its correctness. Each entry is the sum of the three entries directly above it. All non existing entries are considered 0.
&lt;center&gt;
&lt;math&gt;\begin{array}{ccccccccc}
&amp;&amp;&amp;&amp;1&amp;&amp;&amp;&amp; \\
&amp;&amp;&amp;1&amp;1&amp;1&amp;&amp;&amp;\\
&amp;&amp;1&amp;2&amp;3&amp;2&amp;1&amp;&amp;\\
&amp;1&amp;3&amp;6&amp;7&amp;6&amp;3&amp;1&amp;\\
1&amp;4&amp;10&amp;16&amp;19&amp;16&amp;10&amp;4&amp;1\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.37|Solution]]


:2.38. Assume that Christmas has &lt;math&gt;n&lt;/math&gt; days. Exactly how many presents did my ''true love'' send me? (Do some research if you do not understand this question.)


:[[2.39]]

[[2.39|Solution]]


:2.40. Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n do
      for j=i to 2*i do
         output ''foobar''
&lt;/tt&gt;
:Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as a summation (actually two nested summations).
#Simplify the summation.  Show your work.


:[[2.41]].Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n/2 do
      for j=i to n-i do
         for k=1 to j do
            output ''foobar''
&lt;/tt&gt;
:Assume &lt;math&gt;n&lt;/math&gt; is even. Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as three nested summations.
#Simplify the summation.  Show your work.

[[2.41|Solution]]


:2.42. When you first learned to multiply numbers, you were told that &lt;math&gt;x \times y&lt;/math&gt; means adding &lt;math&gt;x&lt;/math&gt; a total of &lt;math&gt;y&lt;/math&gt; times, so &lt;math&gt;5 \times 4 = 5+5+5+5 = 20&lt;/math&gt;. What is the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers in base &lt;math&gt;b&lt;/math&gt; (people work in base 10, of course, while computers work in base 2) using the repeated addition method, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;. Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time. (Hint: how big can &lt;math&gt;y&lt;/math&gt; be as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;?)


:[[2.43]]. In grade school, you learned to multiply long numbers on a digit-by-digit basis, so that &lt;math&gt;127 \times 211 = 127 \times 1 + 127 \times 10 + 127 \times 200 = 26,397&lt;/math&gt;. Analyze the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers with this method as a function of &lt;math&gt;n&lt;/math&gt; (assume constant base size). Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time.

[[2.43|Solution]]

===Logartihms===


:2.44

:2.45

:2.46

:2.47

===Interview Problems===


:2.48

:2.49

:2.50

:2.51

:2.52

:2.53

:2.54

:2.55


Back to [[Chapter List]]</text>
      <sha1>nggx6d7yhq9m1o0e7eo068xiustfk7p</sha1>
    </revision>
    <revision>
      <id>97</id>
      <parentid>96</parentid>
      <timestamp>2020-09-07T17:00:55Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Logartihms */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="15329">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
       ''return''(r)


:[[2.5]]. Consider the following algorithm: (the print operation prints a single asterisk; the operation &lt;math&gt;x = 2x&lt;/math&gt; doubles the value of the variable &lt;math&gt;x&lt;/math&gt;).
    ''for'' &lt;math&gt; k = 1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt;
        &lt;math&gt;x = k&lt;/math&gt;
        ''while'' (&lt;math&gt;x &lt; n&lt;/math&gt;):
           ''print'' '*'
           &lt;math&gt;x = 2x&lt;/math&gt;
:Let &lt;math&gt;f(n)&lt;/math&gt; be the complexity of this algorithm (or equivalently the number of times * is printed). Proivde correct bounds for &lt;math&gt; O(f(n))&lt;/math&gt;, and &lt;math&gt;/Theta(f(n))&lt;/math&gt;, ideally converging on &lt;math&gt;\Theta(f(n))&lt;/math&gt;.

[[2.5|Solution]]


:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. True or False?
#Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.9|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]. For each of the following functions, which of the following asymptotic bounds hold for &lt;math&gt;f(n) = O(g(n)),\Theta(g(n)),\Omega(g(n))&lt;/math&gt;?

[[2.11|Solution]]


:2.12. Prove that &lt;math&gt;n^3 - 3n^2-n+1 = \Theta(n^3)&lt;/math&gt;.


:2.13. Prove that &lt;math&gt;n^2 = O(2^n)&lt;/math&gt;.

[[2.13|Solution]]


:2.14. Prove or disprove: &lt;math&gt;\Theta(n^2) = \Theta(n^2+1)&lt;/math&gt;.


:[[2.15]]. Suppose you have algorithms with the five running times listed below. (Assume these are the exact running times.) How much slower do each of these inputs get when you (a) double the input size, or (b) increase the input size by one?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;

[[2.15|Solution]]


:2.16.  Suppose you have algorithms with the six running times listed below. (Assume these are the exact number of operations performed as a function of input size &lt;math&gt;n&lt;/math&gt;.)Suppose you have a computer that can perform &lt;math&gt;10^10&lt;/math&gt; operations per second. For each algorithm, what is the largest input size n that you can complete within an hour?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;  (f) &lt;math&gt;2^{2^n}&lt;/math&gt;


:[[2.17]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, give an appropriate positive constant &lt;math&gt;c&lt;/math&gt; such that &lt;math&gt;f(n) \leq c \cdot g(n)&lt;/math&gt; for all &lt;math&gt;n &gt; 1&lt;/math&gt;.
#&lt;math&gt;f(n)=n^2+n+1&lt;/math&gt;, &lt;math&gt;g(n)=2n^3&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n + n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^2&lt;/math&gt;
#&lt;math&gt;f(n)=n^2-n+1&lt;/math&gt;, &lt;math&gt;g(n)=n^2/2&lt;/math&gt;

[[2.17|Solution]]


:2.18. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n) = O(g_1(n)+g_2(n))&lt;/math&gt;.


:[[2.19]]. Prove that if &lt;math&gt;f_1(N)=\Omega(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=\Omega(g_2(n) &lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n)=\Omega(g_1(n)+g_2(n))&lt;/math&gt;.

[[2.19|Solution]]


:2.20. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n) \cdot f_2(n) = O(g_1(n) \cdot g_2(n))&lt;/math&gt;


:[[2.21]]. Prove for all &lt;math&gt;k \geq 1&lt;/math&gt; and all sets of constants &lt;math&gt;\{a_k, a_{k-1}, \ldots, a_1,a_0\} \in R&lt;/math&gt;, &lt;math&gt; a_k n^k + a_{k-1}n^{k-1}+....+a_1 n + a_0 = O(n^k)&lt;/math&gt;

[[2.21|Solution]]


:2.22. Show that for any real constants &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;, &lt;math&gt;b &gt; 0&lt;/math&gt;
&lt;center&gt;&lt;math&gt;(n + a)^b = \Omega (n^b)&lt;/math&gt;&lt;/center&gt;


:[[2.23]]. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{llll}
n &amp; 2^n &amp; n \lg n &amp; \ln n \\
n-n^3+7n^5 &amp; \lg n &amp; \sqrt n &amp; e^n \\
n^2+\lg n &amp; n^2 &amp; 2^{n-1} &amp;  \lg \lg n \\
n^3 &amp; (\lg n)^2 &amp; n! &amp; n^{1+\varepsilon} where 0&lt; \varepsilon &lt;1
\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.23|Solution]]


:2.24


:[[2.25]]

[[2.25|Solution]]


:2.26. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{lll}
\sqrt{n} &amp; n &amp; 2^n \\
n \log n &amp;  n - n^3 + 7n^5 &amp;  n^2 + \log n \\
n^2 &amp;  n^3 &amp;  \log n \\
n^{\frac{1}{3}} + \log n &amp; (\log n)^2 &amp;  n! \\
\ln n &amp; \frac{n}{\log n} &amp;  \log \log n \\
({1}/{3})^n &amp;  ({3}/{2})^n &amp;  6 \\
\end{array}&lt;/math&gt;
&lt;/center&gt;


:[[2.27]]. Find two functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt; that satisfy the following relationship. If no such &lt;math&gt;f&lt;/math&gt; and &lt;math&gt;g&lt;/math&gt; exist, write ''None.''
#&lt;math&gt;f(n)=o(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq \Theta(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n)=o(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;

[[2.27|Solution]]


:2.28. True or False?
#&lt;math&gt;2n^2+1=O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n= O(\log n)&lt;/math&gt;
#&lt;math&gt;\log n = O(\sqrt n)&lt;/math&gt;
#&lt;math&gt;n^2(1 + \sqrt n) = O(n^2 \log n)&lt;/math&gt;
#&lt;math&gt;3n^2 + \sqrt n = O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n \log n= O(n) &lt;/math&gt;
#&lt;math&gt;\log n=O(n^{-1/2})&lt;/math&gt;


:[[2.29]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, state whether &lt;math&gt;f(n)=O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;, or none of the above.
#&lt;math&gt;f(n)=n^2+3n+4&lt;/math&gt;, &lt;math&gt;g(n)=6n+7&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n&lt;/math&gt;, &lt;math&gt;g(n)=n^2-n&lt;/math&gt;
#&lt;math&gt;f(n)=2^n - n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^4+n^2&lt;/math&gt;

[[2.29|Solution]]. 


:2.30. For each of these questions, briefly explain your answer.
&lt;br&gt;
::(a) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
&lt;br&gt;
::(b) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
&lt;br&gt;
::(c) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
&lt;br&gt;
::(d) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
&lt;br&gt;
::(e) Is the function &lt;math&gt;f(n) = \Theta(n^2)&lt;/math&gt;, where &lt;math&gt;f(n) = 100 n^2&lt;/math&gt; for even &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;f(n) = 20 n^2 - n \log_2 n&lt;/math&gt; for odd &lt;math&gt;n&lt;/math&gt;?


:[[2.31]]. For each of the following, answer ''yes'', ''no'', or ''can't tell''. Explain your reasoning.
&lt;br&gt;
::(a) Is &lt;math&gt;3^n = O(2^n)&lt;/math&gt;?
&lt;br&gt;
::(b) Is &lt;math&gt;\log 3^n = O( \log 2^n )&lt;/math&gt;?
&lt;br&gt;
::(c) Is &lt;math&gt;3^n = \Omega(2^n)&lt;/math&gt;?
&lt;br&gt;
::(d) Is &lt;math&gt;\log 3^n = \Omega( \log 2^n )&lt;/math&gt;?

[[2.31|Solution]]


:2.32. For each of the following expressions &lt;math&gt;f(n)&lt;/math&gt; find a simple &lt;math&gt;g(n)&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n {1\over i}&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \lceil {1\over i}\rceil&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \log i&lt;/math&gt;.
#&lt;math&gt;f(n)=\log (n!)&lt;/math&gt;.


:[[2.33]]. Place the following functions into increasing asymptotic order.
::&lt;math&gt;f_1(n) = n^2\log_2n&lt;/math&gt;, &lt;math&gt;f_2(n) = n(\log_2n)^2&lt;/math&gt;, &lt;math&gt;f_3(n) = \sum_{i=0}^n 2^i&lt;/math&gt;, &lt;math&gt;f_4(n) = \log_2(\sum_{i=0}^n 2^i)&lt;/math&gt;.

[[2.33|Solution]]


:2.34. Which of the following are true?
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n-1})&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^n)&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n+1})&lt;/math&gt;.


:[[2.35]]. For each of the following functions &lt;math&gt;f&lt;/math&gt; find a simple function &lt;math&gt;g&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f_1(n)= (1000)2^n + 4^n&lt;/math&gt;.
#&lt;math&gt;f_2(n)= n + n\log n + \sqrt n&lt;/math&gt;.
#&lt;math&gt;f_3(n)= \log (n^{20}) + (\log n)^{10}&lt;/math&gt;.
#&lt;math&gt;f_4(n)= (0.99)^n + n^{100}.&lt;/math&gt;

[[2.35|Solution]]


:2.36. For each pair of expressions &lt;math&gt;(A,B)&lt;/math&gt; below, indicate whether &lt;math&gt;A&lt;/math&gt; is &lt;math&gt;O&lt;/math&gt;, &lt;math&gt;o&lt;/math&gt;, &lt;math&gt;\Omega&lt;/math&gt;, &lt;math&gt;\omega&lt;/math&gt;, or &lt;math&gt;\Theta&lt;/math&gt; of &lt;math&gt;B&lt;/math&gt;.  Note that zero, one or more of these relations may hold for a given pair; list all correct ones.
&lt;br&gt;&lt;center&gt;&lt;math&gt;
\begin{array}{lcc}
        &amp; A                     &amp; B \\
(a)     &amp; n^{100}               &amp; 2^n \\
(b)     &amp; (\lg n)^{12}         &amp; \sqrt{n} \\
(c)     &amp; \sqrt{n}              &amp; n^{\cos (\pi n/8)} \\
(d)     &amp; 10^n                  &amp; 100^n \\
(e)     &amp; n^{\lg n}            &amp; (\lg n)^n \\
(f)     &amp; \lg{(n!)}            &amp; n \lg n
\end{array}
&lt;/math&gt;&lt;/center&gt;

===Summations===


:[[2.37]]. Find an expression for the sum of the &lt;math&gt;i&lt;/math&gt;th row of the following triangle, and prove its correctness. Each entry is the sum of the three entries directly above it. All non existing entries are considered 0.
&lt;center&gt;
&lt;math&gt;\begin{array}{ccccccccc}
&amp;&amp;&amp;&amp;1&amp;&amp;&amp;&amp; \\
&amp;&amp;&amp;1&amp;1&amp;1&amp;&amp;&amp;\\
&amp;&amp;1&amp;2&amp;3&amp;2&amp;1&amp;&amp;\\
&amp;1&amp;3&amp;6&amp;7&amp;6&amp;3&amp;1&amp;\\
1&amp;4&amp;10&amp;16&amp;19&amp;16&amp;10&amp;4&amp;1\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.37|Solution]]


:2.38. Assume that Christmas has &lt;math&gt;n&lt;/math&gt; days. Exactly how many presents did my ''true love'' send me? (Do some research if you do not understand this question.)


:[[2.39]]

[[2.39|Solution]]


:2.40. Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n do
      for j=i to 2*i do
         output ''foobar''
&lt;/tt&gt;
:Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as a summation (actually two nested summations).
#Simplify the summation.  Show your work.


:[[2.41]].Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n/2 do
      for j=i to n-i do
         for k=1 to j do
            output ''foobar''
&lt;/tt&gt;
:Assume &lt;math&gt;n&lt;/math&gt; is even. Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as three nested summations.
#Simplify the summation.  Show your work.

[[2.41|Solution]]


:2.42. When you first learned to multiply numbers, you were told that &lt;math&gt;x \times y&lt;/math&gt; means adding &lt;math&gt;x&lt;/math&gt; a total of &lt;math&gt;y&lt;/math&gt; times, so &lt;math&gt;5 \times 4 = 5+5+5+5 = 20&lt;/math&gt;. What is the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers in base &lt;math&gt;b&lt;/math&gt; (people work in base 10, of course, while computers work in base 2) using the repeated addition method, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;. Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time. (Hint: how big can &lt;math&gt;y&lt;/math&gt; be as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;?)


:[[2.43]]. In grade school, you learned to multiply long numbers on a digit-by-digit basis, so that &lt;math&gt;127 \times 211 = 127 \times 1 + 127 \times 10 + 127 \times 200 = 26,397&lt;/math&gt;. Analyze the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers with this method as a function of &lt;math&gt;n&lt;/math&gt; (assume constant base size). Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time.

[[2.43|Solution]]

===Logartihms===


:2.44. Prove the following identities on logarithms:
#Prove that &lt;math&gt;\log_a (xy) = \log_a x + \log_a y&lt;/math&gt;
#Prove that &lt;math&gt;\log_a x^y = y \log_a x&lt;/math&gt;
#Prove that &lt;math&gt;\log_a x = \frac{\log_b x}{\log_b a}&lt;/math&gt;
#Prove that &lt;math&gt;x^{\log_b y} = y^{\log_b x}&lt;/math&gt;


:[[2.45]]. Show that &lt;math&gt;\lceil \lg(n+1) \rceil = \lfloor \lg n \rfloor +1&lt;/math&gt;

[[2.45|Solution]]


:2.46. Prove that that the binary representation of &lt;math&gt;n \geq 1&lt;/math&gt; has &lt;math&gt;\lfloor \lg_2 n \rfloor&lt;/math&gt; + &lt;math&gt;1&lt;/math&gt; bits.


:[[2.47]]. In one of my research papers I give a comparison-based sorting algorithm that runs in &lt;math&gt;O( n \log (\sqrt n) )&lt;/math&gt;. Given the existence of an &lt;math&gt;\Omega(n \log n)&lt;/math&gt; lower bound for sorting, how can this be possible?
 

[[2.47|Solution]]

===Interview Problems===


:2.48

:2.49

:2.50

:2.51

:2.52

:2.53

:2.54

:2.55


Back to [[Chapter List]]</text>
      <sha1>kjj9wy8ajdkfxnu8iv218zqr7fmh6vf</sha1>
    </revision>
    <revision>
      <id>98</id>
      <parentid>97</parentid>
      <timestamp>2020-09-07T17:14:38Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Interview Problems */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="17898">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
       ''return''(r)


:[[2.5]]. Consider the following algorithm: (the print operation prints a single asterisk; the operation &lt;math&gt;x = 2x&lt;/math&gt; doubles the value of the variable &lt;math&gt;x&lt;/math&gt;).
    ''for'' &lt;math&gt; k = 1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt;
        &lt;math&gt;x = k&lt;/math&gt;
        ''while'' (&lt;math&gt;x &lt; n&lt;/math&gt;):
           ''print'' '*'
           &lt;math&gt;x = 2x&lt;/math&gt;
:Let &lt;math&gt;f(n)&lt;/math&gt; be the complexity of this algorithm (or equivalently the number of times * is printed). Proivde correct bounds for &lt;math&gt; O(f(n))&lt;/math&gt;, and &lt;math&gt;/Theta(f(n))&lt;/math&gt;, ideally converging on &lt;math&gt;\Theta(f(n))&lt;/math&gt;.

[[2.5|Solution]]


:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. True or False?
#Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.9|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]. For each of the following functions, which of the following asymptotic bounds hold for &lt;math&gt;f(n) = O(g(n)),\Theta(g(n)),\Omega(g(n))&lt;/math&gt;?

[[2.11|Solution]]


:2.12. Prove that &lt;math&gt;n^3 - 3n^2-n+1 = \Theta(n^3)&lt;/math&gt;.


:2.13. Prove that &lt;math&gt;n^2 = O(2^n)&lt;/math&gt;.

[[2.13|Solution]]


:2.14. Prove or disprove: &lt;math&gt;\Theta(n^2) = \Theta(n^2+1)&lt;/math&gt;.


:[[2.15]]. Suppose you have algorithms with the five running times listed below. (Assume these are the exact running times.) How much slower do each of these inputs get when you (a) double the input size, or (b) increase the input size by one?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;

[[2.15|Solution]]


:2.16.  Suppose you have algorithms with the six running times listed below. (Assume these are the exact number of operations performed as a function of input size &lt;math&gt;n&lt;/math&gt;.)Suppose you have a computer that can perform &lt;math&gt;10^10&lt;/math&gt; operations per second. For each algorithm, what is the largest input size n that you can complete within an hour?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;  (f) &lt;math&gt;2^{2^n}&lt;/math&gt;


:[[2.17]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, give an appropriate positive constant &lt;math&gt;c&lt;/math&gt; such that &lt;math&gt;f(n) \leq c \cdot g(n)&lt;/math&gt; for all &lt;math&gt;n &gt; 1&lt;/math&gt;.
#&lt;math&gt;f(n)=n^2+n+1&lt;/math&gt;, &lt;math&gt;g(n)=2n^3&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n + n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^2&lt;/math&gt;
#&lt;math&gt;f(n)=n^2-n+1&lt;/math&gt;, &lt;math&gt;g(n)=n^2/2&lt;/math&gt;

[[2.17|Solution]]


:2.18. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n) = O(g_1(n)+g_2(n))&lt;/math&gt;.


:[[2.19]]. Prove that if &lt;math&gt;f_1(N)=\Omega(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=\Omega(g_2(n) &lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n)=\Omega(g_1(n)+g_2(n))&lt;/math&gt;.

[[2.19|Solution]]


:2.20. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n) \cdot f_2(n) = O(g_1(n) \cdot g_2(n))&lt;/math&gt;


:[[2.21]]. Prove for all &lt;math&gt;k \geq 1&lt;/math&gt; and all sets of constants &lt;math&gt;\{a_k, a_{k-1}, \ldots, a_1,a_0\} \in R&lt;/math&gt;, &lt;math&gt; a_k n^k + a_{k-1}n^{k-1}+....+a_1 n + a_0 = O(n^k)&lt;/math&gt;

[[2.21|Solution]]


:2.22. Show that for any real constants &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;, &lt;math&gt;b &gt; 0&lt;/math&gt;
&lt;center&gt;&lt;math&gt;(n + a)^b = \Omega (n^b)&lt;/math&gt;&lt;/center&gt;


:[[2.23]]. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{llll}
n &amp; 2^n &amp; n \lg n &amp; \ln n \\
n-n^3+7n^5 &amp; \lg n &amp; \sqrt n &amp; e^n \\
n^2+\lg n &amp; n^2 &amp; 2^{n-1} &amp;  \lg \lg n \\
n^3 &amp; (\lg n)^2 &amp; n! &amp; n^{1+\varepsilon} where 0&lt; \varepsilon &lt;1
\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.23|Solution]]


:2.24


:[[2.25]]

[[2.25|Solution]]


:2.26. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{lll}
\sqrt{n} &amp; n &amp; 2^n \\
n \log n &amp;  n - n^3 + 7n^5 &amp;  n^2 + \log n \\
n^2 &amp;  n^3 &amp;  \log n \\
n^{\frac{1}{3}} + \log n &amp; (\log n)^2 &amp;  n! \\
\ln n &amp; \frac{n}{\log n} &amp;  \log \log n \\
({1}/{3})^n &amp;  ({3}/{2})^n &amp;  6 \\
\end{array}&lt;/math&gt;
&lt;/center&gt;


:[[2.27]]. Find two functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt; that satisfy the following relationship. If no such &lt;math&gt;f&lt;/math&gt; and &lt;math&gt;g&lt;/math&gt; exist, write ''None.''
#&lt;math&gt;f(n)=o(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq \Theta(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n)=o(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;

[[2.27|Solution]]


:2.28. True or False?
#&lt;math&gt;2n^2+1=O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n= O(\log n)&lt;/math&gt;
#&lt;math&gt;\log n = O(\sqrt n)&lt;/math&gt;
#&lt;math&gt;n^2(1 + \sqrt n) = O(n^2 \log n)&lt;/math&gt;
#&lt;math&gt;3n^2 + \sqrt n = O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n \log n= O(n) &lt;/math&gt;
#&lt;math&gt;\log n=O(n^{-1/2})&lt;/math&gt;


:[[2.29]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, state whether &lt;math&gt;f(n)=O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;, or none of the above.
#&lt;math&gt;f(n)=n^2+3n+4&lt;/math&gt;, &lt;math&gt;g(n)=6n+7&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n&lt;/math&gt;, &lt;math&gt;g(n)=n^2-n&lt;/math&gt;
#&lt;math&gt;f(n)=2^n - n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^4+n^2&lt;/math&gt;

[[2.29|Solution]]. 


:2.30. For each of these questions, briefly explain your answer.
&lt;br&gt;
::(a) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
&lt;br&gt;
::(b) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
&lt;br&gt;
::(c) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
&lt;br&gt;
::(d) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
&lt;br&gt;
::(e) Is the function &lt;math&gt;f(n) = \Theta(n^2)&lt;/math&gt;, where &lt;math&gt;f(n) = 100 n^2&lt;/math&gt; for even &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;f(n) = 20 n^2 - n \log_2 n&lt;/math&gt; for odd &lt;math&gt;n&lt;/math&gt;?


:[[2.31]]. For each of the following, answer ''yes'', ''no'', or ''can't tell''. Explain your reasoning.
&lt;br&gt;
::(a) Is &lt;math&gt;3^n = O(2^n)&lt;/math&gt;?
&lt;br&gt;
::(b) Is &lt;math&gt;\log 3^n = O( \log 2^n )&lt;/math&gt;?
&lt;br&gt;
::(c) Is &lt;math&gt;3^n = \Omega(2^n)&lt;/math&gt;?
&lt;br&gt;
::(d) Is &lt;math&gt;\log 3^n = \Omega( \log 2^n )&lt;/math&gt;?

[[2.31|Solution]]


:2.32. For each of the following expressions &lt;math&gt;f(n)&lt;/math&gt; find a simple &lt;math&gt;g(n)&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n {1\over i}&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \lceil {1\over i}\rceil&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \log i&lt;/math&gt;.
#&lt;math&gt;f(n)=\log (n!)&lt;/math&gt;.


:[[2.33]]. Place the following functions into increasing asymptotic order.
::&lt;math&gt;f_1(n) = n^2\log_2n&lt;/math&gt;, &lt;math&gt;f_2(n) = n(\log_2n)^2&lt;/math&gt;, &lt;math&gt;f_3(n) = \sum_{i=0}^n 2^i&lt;/math&gt;, &lt;math&gt;f_4(n) = \log_2(\sum_{i=0}^n 2^i)&lt;/math&gt;.

[[2.33|Solution]]


:2.34. Which of the following are true?
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n-1})&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^n)&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n+1})&lt;/math&gt;.


:[[2.35]]. For each of the following functions &lt;math&gt;f&lt;/math&gt; find a simple function &lt;math&gt;g&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f_1(n)= (1000)2^n + 4^n&lt;/math&gt;.
#&lt;math&gt;f_2(n)= n + n\log n + \sqrt n&lt;/math&gt;.
#&lt;math&gt;f_3(n)= \log (n^{20}) + (\log n)^{10}&lt;/math&gt;.
#&lt;math&gt;f_4(n)= (0.99)^n + n^{100}.&lt;/math&gt;

[[2.35|Solution]]


:2.36. For each pair of expressions &lt;math&gt;(A,B)&lt;/math&gt; below, indicate whether &lt;math&gt;A&lt;/math&gt; is &lt;math&gt;O&lt;/math&gt;, &lt;math&gt;o&lt;/math&gt;, &lt;math&gt;\Omega&lt;/math&gt;, &lt;math&gt;\omega&lt;/math&gt;, or &lt;math&gt;\Theta&lt;/math&gt; of &lt;math&gt;B&lt;/math&gt;.  Note that zero, one or more of these relations may hold for a given pair; list all correct ones.
&lt;br&gt;&lt;center&gt;&lt;math&gt;
\begin{array}{lcc}
        &amp; A                     &amp; B \\
(a)     &amp; n^{100}               &amp; 2^n \\
(b)     &amp; (\lg n)^{12}         &amp; \sqrt{n} \\
(c)     &amp; \sqrt{n}              &amp; n^{\cos (\pi n/8)} \\
(d)     &amp; 10^n                  &amp; 100^n \\
(e)     &amp; n^{\lg n}            &amp; (\lg n)^n \\
(f)     &amp; \lg{(n!)}            &amp; n \lg n
\end{array}
&lt;/math&gt;&lt;/center&gt;

===Summations===


:[[2.37]]. Find an expression for the sum of the &lt;math&gt;i&lt;/math&gt;th row of the following triangle, and prove its correctness. Each entry is the sum of the three entries directly above it. All non existing entries are considered 0.
&lt;center&gt;
&lt;math&gt;\begin{array}{ccccccccc}
&amp;&amp;&amp;&amp;1&amp;&amp;&amp;&amp; \\
&amp;&amp;&amp;1&amp;1&amp;1&amp;&amp;&amp;\\
&amp;&amp;1&amp;2&amp;3&amp;2&amp;1&amp;&amp;\\
&amp;1&amp;3&amp;6&amp;7&amp;6&amp;3&amp;1&amp;\\
1&amp;4&amp;10&amp;16&amp;19&amp;16&amp;10&amp;4&amp;1\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.37|Solution]]


:2.38. Assume that Christmas has &lt;math&gt;n&lt;/math&gt; days. Exactly how many presents did my ''true love'' send me? (Do some research if you do not understand this question.)


:[[2.39]]

[[2.39|Solution]]


:2.40. Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n do
      for j=i to 2*i do
         output ''foobar''
&lt;/tt&gt;
:Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as a summation (actually two nested summations).
#Simplify the summation.  Show your work.


:[[2.41]].Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n/2 do
      for j=i to n-i do
         for k=1 to j do
            output ''foobar''
&lt;/tt&gt;
:Assume &lt;math&gt;n&lt;/math&gt; is even. Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as three nested summations.
#Simplify the summation.  Show your work.

[[2.41|Solution]]


:2.42. When you first learned to multiply numbers, you were told that &lt;math&gt;x \times y&lt;/math&gt; means adding &lt;math&gt;x&lt;/math&gt; a total of &lt;math&gt;y&lt;/math&gt; times, so &lt;math&gt;5 \times 4 = 5+5+5+5 = 20&lt;/math&gt;. What is the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers in base &lt;math&gt;b&lt;/math&gt; (people work in base 10, of course, while computers work in base 2) using the repeated addition method, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;. Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time. (Hint: how big can &lt;math&gt;y&lt;/math&gt; be as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;?)


:[[2.43]]. In grade school, you learned to multiply long numbers on a digit-by-digit basis, so that &lt;math&gt;127 \times 211 = 127 \times 1 + 127 \times 10 + 127 \times 200 = 26,397&lt;/math&gt;. Analyze the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers with this method as a function of &lt;math&gt;n&lt;/math&gt; (assume constant base size). Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time.

[[2.43|Solution]]

===Logartihms===


:2.44. Prove the following identities on logarithms:
#Prove that &lt;math&gt;\log_a (xy) = \log_a x + \log_a y&lt;/math&gt;
#Prove that &lt;math&gt;\log_a x^y = y \log_a x&lt;/math&gt;
#Prove that &lt;math&gt;\log_a x = \frac{\log_b x}{\log_b a}&lt;/math&gt;
#Prove that &lt;math&gt;x^{\log_b y} = y^{\log_b x}&lt;/math&gt;


:[[2.45]]. Show that &lt;math&gt;\lceil \lg(n+1) \rceil = \lfloor \lg n \rfloor +1&lt;/math&gt;

[[2.45|Solution]]


:2.46. Prove that that the binary representation of &lt;math&gt;n \geq 1&lt;/math&gt; has &lt;math&gt;\lfloor \lg_2 n \rfloor&lt;/math&gt; + &lt;math&gt;1&lt;/math&gt; bits.


:[[2.47]]. In one of my research papers I give a comparison-based sorting algorithm that runs in &lt;math&gt;O( n \log (\sqrt n) )&lt;/math&gt;. Given the existence of an &lt;math&gt;\Omega(n \log n)&lt;/math&gt; lower bound for sorting, how can this be possible?
 

[[2.47|Solution]]

===Interview Problems===


:2.48. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; numbers. You must pick a subset &lt;math&gt;S'&lt;/math&gt; of &lt;math&gt;k&lt;/math&gt; numbers from &lt;math&gt;S&lt;/math&gt; such that the probability of each element of &lt;math&gt;S&lt;/math&gt; occurring in &lt;math&gt;S'&lt;/math&gt; is equal (i.e., each is selected with probability &lt;math&gt;k/n&lt;/math&gt;). You may make only one pass over the numbers. What if &lt;math&gt;n&lt;/math&gt; is unknown?


:[[2.49]]. We have 1,000 data items to store on 1,000 nodes. Each node can store copies of exactly three different items. Propose a replication scheme to minimize data loss as nodes fail. What is the expected number of data entries that get lost when three random nodes fail?

[[2.49|Solution]]


:2.50. Consider the following algorithm to find the minimum element in an array of numbers &lt;math&gt;A[0, \ldots, n]&lt;/math&gt;. One extra variable &lt;math&gt;tmp&lt;/math&gt; is allocated to hold the current minimum value. Start from A[0]; "tmp" is compared against &lt;math&gt;A[1]&lt;/math&gt;, 
&lt;math&gt;A[2]&lt;/math&gt;, &lt;math&gt;\ldots&lt;/math&gt;, &lt;math&gt;A[N]&lt;/math&gt; in order. When &lt;math&gt;A[i]&lt;tmp&lt;/math&gt;, &lt;math&gt;tmp = A[i]&lt;/math&gt;. What is the expected number of times that the assignment operation &lt;math&gt;tmp = A[i]&lt;/math&gt; is performed?


:[[2.51]]. You are given ten bags of gold coins. Nine bags contain coins that each weigh 10 grams. One bag contains all false coins that weigh 1 gram less. You must identify this bag in just one weighing. You have a digital balance that reports the weight of what is placed on it.

[[2.51|Solution]]


:2.52. You have eight balls all of the same size. Seven of them weigh the same, and one of them weighs slightly more. How can you find the ball that is heavier by using a balance and only two weightings?


:[[2.53]]. Suppose we start with &lt;math&gt;n&lt;/math&gt; companies that eventually merge into one big company. How many different ways are there for them to merge?

[[2.53|Solution]]


:2.54. Six pirates must divide $300 among themselves. The division is to proceed as follows. The senior pirate proposes a way to divide the money. Then the pirates vote. If the senior pirate gets at least half the votes he wins, and that division remains. If he doesn’t, he is killed and then the next senior-most pirate gets a chance to propose the division. Now tell what will happen and why (i.e. how many pirates survive and how the division is done)? All the pirates are intelligent and the first priority is to stay alive and the next priority is to get as much money as possible.


:[[2.55]]. Reconsider the pirate problem above, where we start with only one indivisible dollar. Who gets the dollar, and how many are killed?

[[2.55|Solution]]


Back to [[Chapter List]]</text>
      <sha1>jlmz7nbgq3bl3jm5yjbzxuuv8q4tguk</sha1>
    </revision>
    <revision>
      <id>99</id>
      <parentid>98</parentid>
      <timestamp>2020-09-07T17:20:02Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Big Oh */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="17853">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
       ''return''(r)


:[[2.5]]. Consider the following algorithm: (the print operation prints a single asterisk; the operation &lt;math&gt;x = 2x&lt;/math&gt; doubles the value of the variable &lt;math&gt;x&lt;/math&gt;).
    ''for'' &lt;math&gt; k = 1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt;
        &lt;math&gt;x = k&lt;/math&gt;
        ''while'' (&lt;math&gt;x &lt; n&lt;/math&gt;):
           ''print'' '*'
           &lt;math&gt;x = 2x&lt;/math&gt;
:Let &lt;math&gt;f(n)&lt;/math&gt; be the complexity of this algorithm (or equivalently the number of times * is printed). Proivde correct bounds for &lt;math&gt; O(f(n))&lt;/math&gt;, and &lt;math&gt;/Theta(f(n))&lt;/math&gt;, ideally converging on &lt;math&gt;\Theta(f(n))&lt;/math&gt;.

[[2.5|Solution]]


:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. True or False?
#Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.9|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]. For each of the following functions, which of the following asymptotic bounds hold for &lt;math&gt;f(n) = O(g(n)),\Theta(g(n)),\Omega(g(n))&lt;/math&gt;?

[[2.11|Solution]]


:2.12. Prove that &lt;math&gt;n^3 - 3n^2-n+1 = \Theta(n^3)&lt;/math&gt;.


:2.13. Prove that &lt;math&gt;n^2 = O(2^n)&lt;/math&gt;.

[[2.13|Solution]]


:2.14. Prove or disprove: &lt;math&gt;\Theta(n^2) = \Theta(n^2+1)&lt;/math&gt;.


:[[2.15]]. Suppose you have algorithms with the five running times listed below. (Assume these are the exact running times.) How much slower do each of these inputs get when you (a) double the input size, or (b) increase the input size by one?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;

[[2.15|Solution]]


:2.16.  Suppose you have algorithms with the six running times listed below. (Assume these are the exact number of operations performed as a function of input size &lt;math&gt;n&lt;/math&gt;.)Suppose you have a computer that can perform &lt;math&gt;10^10&lt;/math&gt; operations per second. For each algorithm, what is the largest input size n that you can complete within an hour?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;  (f) &lt;math&gt;2^{2^n}&lt;/math&gt;


:[[2.17]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, give an appropriate positive constant &lt;math&gt;c&lt;/math&gt; such that &lt;math&gt;f(n) \leq c \cdot g(n)&lt;/math&gt; for all &lt;math&gt;n &gt; 1&lt;/math&gt;.
#&lt;math&gt;f(n)=n^2+n+1&lt;/math&gt;, &lt;math&gt;g(n)=2n^3&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n + n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^2&lt;/math&gt;
#&lt;math&gt;f(n)=n^2-n+1&lt;/math&gt;, &lt;math&gt;g(n)=n^2/2&lt;/math&gt;

[[2.17|Solution]]


:2.18. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n) = O(g_1(n)+g_2(n))&lt;/math&gt;.


:[[2.19]]. Prove that if &lt;math&gt;f_1(N)=\Omega(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=\Omega(g_2(n) &lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n)=\Omega(g_1(n)+g_2(n))&lt;/math&gt;.

[[2.19|Solution]]


:2.20. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n) \cdot f_2(n) = O(g_1(n) \cdot g_2(n))&lt;/math&gt;


:[[2.21]]. Prove for all &lt;math&gt;k \geq 1&lt;/math&gt; and all sets of constants &lt;math&gt;\{a_k, a_{k-1}, \ldots, a_1,a_0\} \in R&lt;/math&gt;, &lt;math&gt; a_k n^k + a_{k-1}n^{k-1}+....+a_1 n + a_0 = O(n^k)&lt;/math&gt;

[[2.21|Solution]]


:2.22. Show that for any real constants &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;, &lt;math&gt;b &gt; 0&lt;/math&gt;
&lt;center&gt;&lt;math&gt;(n + a)^b = \Omega (n^b)&lt;/math&gt;&lt;/center&gt;


:[[2.23]]. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{llll}
n &amp; 2^n &amp; n \lg n &amp; \ln n \\
n-n^3+7n^5 &amp; \lg n &amp; \sqrt n &amp; e^n \\
n^2+\lg n &amp; n^2 &amp; 2^{n-1} &amp;  \lg \lg n \\
n^3 &amp; (\lg n)^2 &amp; n! &amp; n^{1+\varepsilon} where 0&lt; \varepsilon &lt;1
\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.23|Solution]]


:2.24


:[[2.25]]

[[2.25|Solution]]


:2.26. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{lll}
\sqrt{n} &amp; n &amp; 2^n \\
n \log n &amp;  n - n^3 + 7n^5 &amp;  n^2 + \log n \\
n^2 &amp;  n^3 &amp;  \log n \\
n^{\frac{1}{3}} + \log n &amp; (\log n)^2 &amp;  n! \\
\ln n &amp; \frac{n}{\log n} &amp;  \log \log n \\
({1}/{3})^n &amp;  ({3}/{2})^n &amp;  6 \\
\end{array}&lt;/math&gt;
&lt;/center&gt;


:[[2.27]]. Find two functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt; that satisfy the following relationship. If no such &lt;math&gt;f&lt;/math&gt; and &lt;math&gt;g&lt;/math&gt; exist, write ''None.''
#&lt;math&gt;f(n)=o(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq \Theta(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n)=o(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;

[[2.27|Solution]]


:2.28. True or False?
#&lt;math&gt;2n^2+1=O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n= O(\log n)&lt;/math&gt;
#&lt;math&gt;\log n = O(\sqrt n)&lt;/math&gt;
#&lt;math&gt;n^2(1 + \sqrt n) = O(n^2 \log n)&lt;/math&gt;
#&lt;math&gt;3n^2 + \sqrt n = O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n \log n= O(n) &lt;/math&gt;
#&lt;math&gt;\log n=O(n^{-1/2})&lt;/math&gt;


:[[2.29]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, state whether &lt;math&gt;f(n)=O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;, or none of the above.
#&lt;math&gt;f(n)=n^2+3n+4&lt;/math&gt;, &lt;math&gt;g(n)=6n+7&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n&lt;/math&gt;, &lt;math&gt;g(n)=n^2-n&lt;/math&gt;
#&lt;math&gt;f(n)=2^n - n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^4+n^2&lt;/math&gt;

[[2.29|Solution]]. 


:2.30. For each of these questions, briefly explain your answer.
::(a) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
::(b) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
::(c) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
::(d) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
::(e) Is the function &lt;math&gt;f(n) = \Theta(n^2)&lt;/math&gt;, where &lt;math&gt;f(n) = 100 n^2&lt;/math&gt; for even &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;f(n) = 20 n^2 - n \log_2 n&lt;/math&gt; for odd &lt;math&gt;n&lt;/math&gt;?


:[[2.31]]. For each of the following, answer ''yes'', ''no'', or ''can't tell''. Explain your reasoning.
::(a) Is &lt;math&gt;3^n = O(2^n)&lt;/math&gt;?
::(b) Is &lt;math&gt;\log 3^n = O( \log 2^n )&lt;/math&gt;?
::(c) Is &lt;math&gt;3^n = \Omega(2^n)&lt;/math&gt;?
::(d) Is &lt;math&gt;\log 3^n = \Omega( \log 2^n )&lt;/math&gt;?

[[2.31|Solution]]


:2.32. For each of the following expressions &lt;math&gt;f(n)&lt;/math&gt; find a simple &lt;math&gt;g(n)&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n {1\over i}&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \lceil {1\over i}\rceil&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \log i&lt;/math&gt;.
#&lt;math&gt;f(n)=\log (n!)&lt;/math&gt;.


:[[2.33]]. Place the following functions into increasing asymptotic order.
::&lt;math&gt;f_1(n) = n^2\log_2n&lt;/math&gt;, &lt;math&gt;f_2(n) = n(\log_2n)^2&lt;/math&gt;, &lt;math&gt;f_3(n) = \sum_{i=0}^n 2^i&lt;/math&gt;, &lt;math&gt;f_4(n) = \log_2(\sum_{i=0}^n 2^i)&lt;/math&gt;.

[[2.33|Solution]]


:2.34. Which of the following are true?
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n-1})&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^n)&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n+1})&lt;/math&gt;.


:[[2.35]]. For each of the following functions &lt;math&gt;f&lt;/math&gt; find a simple function &lt;math&gt;g&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f_1(n)= (1000)2^n + 4^n&lt;/math&gt;.
#&lt;math&gt;f_2(n)= n + n\log n + \sqrt n&lt;/math&gt;.
#&lt;math&gt;f_3(n)= \log (n^{20}) + (\log n)^{10}&lt;/math&gt;.
#&lt;math&gt;f_4(n)= (0.99)^n + n^{100}.&lt;/math&gt;

[[2.35|Solution]]


:2.36. For each pair of expressions &lt;math&gt;(A,B)&lt;/math&gt; below, indicate whether &lt;math&gt;A&lt;/math&gt; is &lt;math&gt;O&lt;/math&gt;, &lt;math&gt;o&lt;/math&gt;, &lt;math&gt;\Omega&lt;/math&gt;, &lt;math&gt;\omega&lt;/math&gt;, or &lt;math&gt;\Theta&lt;/math&gt; of &lt;math&gt;B&lt;/math&gt;.  Note that zero, one or more of these relations may hold for a given pair; list all correct ones.
&lt;br&gt;&lt;center&gt;&lt;math&gt;
\begin{array}{lcc}
        &amp; A                     &amp; B \\
(a)     &amp; n^{100}               &amp; 2^n \\
(b)     &amp; (\lg n)^{12}         &amp; \sqrt{n} \\
(c)     &amp; \sqrt{n}              &amp; n^{\cos (\pi n/8)} \\
(d)     &amp; 10^n                  &amp; 100^n \\
(e)     &amp; n^{\lg n}            &amp; (\lg n)^n \\
(f)     &amp; \lg{(n!)}            &amp; n \lg n
\end{array}
&lt;/math&gt;&lt;/center&gt;

===Summations===


:[[2.37]]. Find an expression for the sum of the &lt;math&gt;i&lt;/math&gt;th row of the following triangle, and prove its correctness. Each entry is the sum of the three entries directly above it. All non existing entries are considered 0.
&lt;center&gt;
&lt;math&gt;\begin{array}{ccccccccc}
&amp;&amp;&amp;&amp;1&amp;&amp;&amp;&amp; \\
&amp;&amp;&amp;1&amp;1&amp;1&amp;&amp;&amp;\\
&amp;&amp;1&amp;2&amp;3&amp;2&amp;1&amp;&amp;\\
&amp;1&amp;3&amp;6&amp;7&amp;6&amp;3&amp;1&amp;\\
1&amp;4&amp;10&amp;16&amp;19&amp;16&amp;10&amp;4&amp;1\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.37|Solution]]


:2.38. Assume that Christmas has &lt;math&gt;n&lt;/math&gt; days. Exactly how many presents did my ''true love'' send me? (Do some research if you do not understand this question.)


:[[2.39]]

[[2.39|Solution]]


:2.40. Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n do
      for j=i to 2*i do
         output ''foobar''
&lt;/tt&gt;
:Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as a summation (actually two nested summations).
#Simplify the summation.  Show your work.


:[[2.41]].Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n/2 do
      for j=i to n-i do
         for k=1 to j do
            output ''foobar''
&lt;/tt&gt;
:Assume &lt;math&gt;n&lt;/math&gt; is even. Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as three nested summations.
#Simplify the summation.  Show your work.

[[2.41|Solution]]


:2.42. When you first learned to multiply numbers, you were told that &lt;math&gt;x \times y&lt;/math&gt; means adding &lt;math&gt;x&lt;/math&gt; a total of &lt;math&gt;y&lt;/math&gt; times, so &lt;math&gt;5 \times 4 = 5+5+5+5 = 20&lt;/math&gt;. What is the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers in base &lt;math&gt;b&lt;/math&gt; (people work in base 10, of course, while computers work in base 2) using the repeated addition method, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;. Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time. (Hint: how big can &lt;math&gt;y&lt;/math&gt; be as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;?)


:[[2.43]]. In grade school, you learned to multiply long numbers on a digit-by-digit basis, so that &lt;math&gt;127 \times 211 = 127 \times 1 + 127 \times 10 + 127 \times 200 = 26,397&lt;/math&gt;. Analyze the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers with this method as a function of &lt;math&gt;n&lt;/math&gt; (assume constant base size). Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time.

[[2.43|Solution]]

===Logartihms===


:2.44. Prove the following identities on logarithms:
#Prove that &lt;math&gt;\log_a (xy) = \log_a x + \log_a y&lt;/math&gt;
#Prove that &lt;math&gt;\log_a x^y = y \log_a x&lt;/math&gt;
#Prove that &lt;math&gt;\log_a x = \frac{\log_b x}{\log_b a}&lt;/math&gt;
#Prove that &lt;math&gt;x^{\log_b y} = y^{\log_b x}&lt;/math&gt;


:[[2.45]]. Show that &lt;math&gt;\lceil \lg(n+1) \rceil = \lfloor \lg n \rfloor +1&lt;/math&gt;

[[2.45|Solution]]


:2.46. Prove that that the binary representation of &lt;math&gt;n \geq 1&lt;/math&gt; has &lt;math&gt;\lfloor \lg_2 n \rfloor&lt;/math&gt; + &lt;math&gt;1&lt;/math&gt; bits.


:[[2.47]]. In one of my research papers I give a comparison-based sorting algorithm that runs in &lt;math&gt;O( n \log (\sqrt n) )&lt;/math&gt;. Given the existence of an &lt;math&gt;\Omega(n \log n)&lt;/math&gt; lower bound for sorting, how can this be possible?
 

[[2.47|Solution]]

===Interview Problems===


:2.48. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; numbers. You must pick a subset &lt;math&gt;S'&lt;/math&gt; of &lt;math&gt;k&lt;/math&gt; numbers from &lt;math&gt;S&lt;/math&gt; such that the probability of each element of &lt;math&gt;S&lt;/math&gt; occurring in &lt;math&gt;S'&lt;/math&gt; is equal (i.e., each is selected with probability &lt;math&gt;k/n&lt;/math&gt;). You may make only one pass over the numbers. What if &lt;math&gt;n&lt;/math&gt; is unknown?


:[[2.49]]. We have 1,000 data items to store on 1,000 nodes. Each node can store copies of exactly three different items. Propose a replication scheme to minimize data loss as nodes fail. What is the expected number of data entries that get lost when three random nodes fail?

[[2.49|Solution]]


:2.50. Consider the following algorithm to find the minimum element in an array of numbers &lt;math&gt;A[0, \ldots, n]&lt;/math&gt;. One extra variable &lt;math&gt;tmp&lt;/math&gt; is allocated to hold the current minimum value. Start from A[0]; "tmp" is compared against &lt;math&gt;A[1]&lt;/math&gt;, 
&lt;math&gt;A[2]&lt;/math&gt;, &lt;math&gt;\ldots&lt;/math&gt;, &lt;math&gt;A[N]&lt;/math&gt; in order. When &lt;math&gt;A[i]&lt;tmp&lt;/math&gt;, &lt;math&gt;tmp = A[i]&lt;/math&gt;. What is the expected number of times that the assignment operation &lt;math&gt;tmp = A[i]&lt;/math&gt; is performed?


:[[2.51]]. You are given ten bags of gold coins. Nine bags contain coins that each weigh 10 grams. One bag contains all false coins that weigh 1 gram less. You must identify this bag in just one weighing. You have a digital balance that reports the weight of what is placed on it.

[[2.51|Solution]]


:2.52. You have eight balls all of the same size. Seven of them weigh the same, and one of them weighs slightly more. How can you find the ball that is heavier by using a balance and only two weightings?


:[[2.53]]. Suppose we start with &lt;math&gt;n&lt;/math&gt; companies that eventually merge into one big company. How many different ways are there for them to merge?

[[2.53|Solution]]


:2.54. Six pirates must divide $300 among themselves. The division is to proceed as follows. The senior pirate proposes a way to divide the money. Then the pirates vote. If the senior pirate gets at least half the votes he wins, and that division remains. If he doesn’t, he is killed and then the next senior-most pirate gets a chance to propose the division. Now tell what will happen and why (i.e. how many pirates survive and how the division is done)? All the pirates are intelligent and the first priority is to stay alive and the next priority is to get as much money as possible.


:[[2.55]]. Reconsider the pirate problem above, where we start with only one indivisible dollar. Who gets the dollar, and how many are killed?

[[2.55|Solution]]


Back to [[Chapter List]]</text>
      <sha1>rjuj17oatydco0kqm7hlkxc2h9ndjyb</sha1>
    </revision>
    <revision>
      <id>129</id>
      <parentid>99</parentid>
      <timestamp>2020-09-09T18:58:28Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Big Oh */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="18064">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
       ''return''(r)


:[[2.5]]. Consider the following algorithm: (the print operation prints a single asterisk; the operation &lt;math&gt;x = 2x&lt;/math&gt; doubles the value of the variable &lt;math&gt;x&lt;/math&gt;).
    ''for'' &lt;math&gt; k = 1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt;
        &lt;math&gt;x = k&lt;/math&gt;
        ''while'' (&lt;math&gt;x &lt; n&lt;/math&gt;):
           ''print'' '*'
           &lt;math&gt;x = 2x&lt;/math&gt;
:Let &lt;math&gt;f(n)&lt;/math&gt; be the complexity of this algorithm (or equivalently the number of times * is printed). Proivde correct bounds for &lt;math&gt; O(f(n))&lt;/math&gt;, and &lt;math&gt;/Theta(f(n))&lt;/math&gt;, ideally converging on &lt;math&gt;\Theta(f(n))&lt;/math&gt;.

[[2.5|Solution]]


:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. True or False?
#Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.9|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]. For each of the following functions, which of the following asymptotic bounds hold for &lt;math&gt;f(n) = O(g(n)),\Theta(g(n)),\Omega(g(n))&lt;/math&gt;?
#&lt;math&gt;f(n) = 3n^2, g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = 2n^4 - 3n^2 + 7, g(n) = n^5&lt;/math&gt;
#&lt;math&gt;f(n) = log n, g(n) = log n + 1/n
#&lt;math&gt;f(n) = 2^(klog n), g(n) = n^k&lt;/math&gt;
#&lt;math&gt;f(n) = 2^n, g(n) = 2^(2n)&lt;/math&gt;

[[2.11|Solution]]


:2.12. Prove that &lt;math&gt;n^3 - 3n^2-n+1 = \Theta(n^3)&lt;/math&gt;.


:2.13. Prove that &lt;math&gt;n^2 = O(2^n)&lt;/math&gt;.

[[2.13|Solution]]


:2.14. Prove or disprove: &lt;math&gt;\Theta(n^2) = \Theta(n^2+1)&lt;/math&gt;.


:[[2.15]]. Suppose you have algorithms with the five running times listed below. (Assume these are the exact running times.) How much slower do each of these inputs get when you (a) double the input size, or (b) increase the input size by one?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;

[[2.15|Solution]]


:2.16.  Suppose you have algorithms with the six running times listed below. (Assume these are the exact number of operations performed as a function of input size &lt;math&gt;n&lt;/math&gt;.)Suppose you have a computer that can perform &lt;math&gt;10^10&lt;/math&gt; operations per second. For each algorithm, what is the largest input size n that you can complete within an hour?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;  (f) &lt;math&gt;2^{2^n}&lt;/math&gt;


:[[2.17]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, give an appropriate positive constant &lt;math&gt;c&lt;/math&gt; such that &lt;math&gt;f(n) \leq c \cdot g(n)&lt;/math&gt; for all &lt;math&gt;n &gt; 1&lt;/math&gt;.
#&lt;math&gt;f(n)=n^2+n+1&lt;/math&gt;, &lt;math&gt;g(n)=2n^3&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n + n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^2&lt;/math&gt;
#&lt;math&gt;f(n)=n^2-n+1&lt;/math&gt;, &lt;math&gt;g(n)=n^2/2&lt;/math&gt;

[[2.17|Solution]]


:2.18. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n) = O(g_1(n)+g_2(n))&lt;/math&gt;.


:[[2.19]]. Prove that if &lt;math&gt;f_1(N)=\Omega(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=\Omega(g_2(n) &lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n)=\Omega(g_1(n)+g_2(n))&lt;/math&gt;.

[[2.19|Solution]]


:2.20. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n) \cdot f_2(n) = O(g_1(n) \cdot g_2(n))&lt;/math&gt;


:[[2.21]]. Prove for all &lt;math&gt;k \geq 1&lt;/math&gt; and all sets of constants &lt;math&gt;\{a_k, a_{k-1}, \ldots, a_1,a_0\} \in R&lt;/math&gt;, &lt;math&gt; a_k n^k + a_{k-1}n^{k-1}+....+a_1 n + a_0 = O(n^k)&lt;/math&gt;

[[2.21|Solution]]


:2.22. Show that for any real constants &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;, &lt;math&gt;b &gt; 0&lt;/math&gt;
&lt;center&gt;&lt;math&gt;(n + a)^b = \Omega (n^b)&lt;/math&gt;&lt;/center&gt;


:[[2.23]]. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{llll}
n &amp; 2^n &amp; n \lg n &amp; \ln n \\
n-n^3+7n^5 &amp; \lg n &amp; \sqrt n &amp; e^n \\
n^2+\lg n &amp; n^2 &amp; 2^{n-1} &amp;  \lg \lg n \\
n^3 &amp; (\lg n)^2 &amp; n! &amp; n^{1+\varepsilon} where 0&lt; \varepsilon &lt;1
\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.23|Solution]]


:2.24


:[[2.25]]

[[2.25|Solution]]


:2.26. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{lll}
\sqrt{n} &amp; n &amp; 2^n \\
n \log n &amp;  n - n^3 + 7n^5 &amp;  n^2 + \log n \\
n^2 &amp;  n^3 &amp;  \log n \\
n^{\frac{1}{3}} + \log n &amp; (\log n)^2 &amp;  n! \\
\ln n &amp; \frac{n}{\log n} &amp;  \log \log n \\
({1}/{3})^n &amp;  ({3}/{2})^n &amp;  6 \\
\end{array}&lt;/math&gt;
&lt;/center&gt;


:[[2.27]]. Find two functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt; that satisfy the following relationship. If no such &lt;math&gt;f&lt;/math&gt; and &lt;math&gt;g&lt;/math&gt; exist, write ''None.''
#&lt;math&gt;f(n)=o(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq \Theta(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n)=o(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;

[[2.27|Solution]]


:2.28. True or False?
#&lt;math&gt;2n^2+1=O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n= O(\log n)&lt;/math&gt;
#&lt;math&gt;\log n = O(\sqrt n)&lt;/math&gt;
#&lt;math&gt;n^2(1 + \sqrt n) = O(n^2 \log n)&lt;/math&gt;
#&lt;math&gt;3n^2 + \sqrt n = O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n \log n= O(n) &lt;/math&gt;
#&lt;math&gt;\log n=O(n^{-1/2})&lt;/math&gt;


:[[2.29]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, state whether &lt;math&gt;f(n)=O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;, or none of the above.
#&lt;math&gt;f(n)=n^2+3n+4&lt;/math&gt;, &lt;math&gt;g(n)=6n+7&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n&lt;/math&gt;, &lt;math&gt;g(n)=n^2-n&lt;/math&gt;
#&lt;math&gt;f(n)=2^n - n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^4+n^2&lt;/math&gt;

[[2.29|Solution]]. 


:2.30. For each of these questions, briefly explain your answer.
::(a) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
::(b) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
::(c) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
::(d) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
::(e) Is the function &lt;math&gt;f(n) = \Theta(n^2)&lt;/math&gt;, where &lt;math&gt;f(n) = 100 n^2&lt;/math&gt; for even &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;f(n) = 20 n^2 - n \log_2 n&lt;/math&gt; for odd &lt;math&gt;n&lt;/math&gt;?


:[[2.31]]. For each of the following, answer ''yes'', ''no'', or ''can't tell''. Explain your reasoning.
::(a) Is &lt;math&gt;3^n = O(2^n)&lt;/math&gt;?
::(b) Is &lt;math&gt;\log 3^n = O( \log 2^n )&lt;/math&gt;?
::(c) Is &lt;math&gt;3^n = \Omega(2^n)&lt;/math&gt;?
::(d) Is &lt;math&gt;\log 3^n = \Omega( \log 2^n )&lt;/math&gt;?

[[2.31|Solution]]


:2.32. For each of the following expressions &lt;math&gt;f(n)&lt;/math&gt; find a simple &lt;math&gt;g(n)&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n {1\over i}&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \lceil {1\over i}\rceil&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \log i&lt;/math&gt;.
#&lt;math&gt;f(n)=\log (n!)&lt;/math&gt;.


:[[2.33]]. Place the following functions into increasing asymptotic order.
::&lt;math&gt;f_1(n) = n^2\log_2n&lt;/math&gt;, &lt;math&gt;f_2(n) = n(\log_2n)^2&lt;/math&gt;, &lt;math&gt;f_3(n) = \sum_{i=0}^n 2^i&lt;/math&gt;, &lt;math&gt;f_4(n) = \log_2(\sum_{i=0}^n 2^i)&lt;/math&gt;.

[[2.33|Solution]]


:2.34. Which of the following are true?
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n-1})&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^n)&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n+1})&lt;/math&gt;.


:[[2.35]]. For each of the following functions &lt;math&gt;f&lt;/math&gt; find a simple function &lt;math&gt;g&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f_1(n)= (1000)2^n + 4^n&lt;/math&gt;.
#&lt;math&gt;f_2(n)= n + n\log n + \sqrt n&lt;/math&gt;.
#&lt;math&gt;f_3(n)= \log (n^{20}) + (\log n)^{10}&lt;/math&gt;.
#&lt;math&gt;f_4(n)= (0.99)^n + n^{100}.&lt;/math&gt;

[[2.35|Solution]]


:2.36. For each pair of expressions &lt;math&gt;(A,B)&lt;/math&gt; below, indicate whether &lt;math&gt;A&lt;/math&gt; is &lt;math&gt;O&lt;/math&gt;, &lt;math&gt;o&lt;/math&gt;, &lt;math&gt;\Omega&lt;/math&gt;, &lt;math&gt;\omega&lt;/math&gt;, or &lt;math&gt;\Theta&lt;/math&gt; of &lt;math&gt;B&lt;/math&gt;.  Note that zero, one or more of these relations may hold for a given pair; list all correct ones.
&lt;br&gt;&lt;center&gt;&lt;math&gt;
\begin{array}{lcc}
        &amp; A                     &amp; B \\
(a)     &amp; n^{100}               &amp; 2^n \\
(b)     &amp; (\lg n)^{12}         &amp; \sqrt{n} \\
(c)     &amp; \sqrt{n}              &amp; n^{\cos (\pi n/8)} \\
(d)     &amp; 10^n                  &amp; 100^n \\
(e)     &amp; n^{\lg n}            &amp; (\lg n)^n \\
(f)     &amp; \lg{(n!)}            &amp; n \lg n
\end{array}
&lt;/math&gt;&lt;/center&gt;

===Summations===


:[[2.37]]. Find an expression for the sum of the &lt;math&gt;i&lt;/math&gt;th row of the following triangle, and prove its correctness. Each entry is the sum of the three entries directly above it. All non existing entries are considered 0.
&lt;center&gt;
&lt;math&gt;\begin{array}{ccccccccc}
&amp;&amp;&amp;&amp;1&amp;&amp;&amp;&amp; \\
&amp;&amp;&amp;1&amp;1&amp;1&amp;&amp;&amp;\\
&amp;&amp;1&amp;2&amp;3&amp;2&amp;1&amp;&amp;\\
&amp;1&amp;3&amp;6&amp;7&amp;6&amp;3&amp;1&amp;\\
1&amp;4&amp;10&amp;16&amp;19&amp;16&amp;10&amp;4&amp;1\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.37|Solution]]


:2.38. Assume that Christmas has &lt;math&gt;n&lt;/math&gt; days. Exactly how many presents did my ''true love'' send me? (Do some research if you do not understand this question.)


:[[2.39]]

[[2.39|Solution]]


:2.40. Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n do
      for j=i to 2*i do
         output ''foobar''
&lt;/tt&gt;
:Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as a summation (actually two nested summations).
#Simplify the summation.  Show your work.


:[[2.41]].Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n/2 do
      for j=i to n-i do
         for k=1 to j do
            output ''foobar''
&lt;/tt&gt;
:Assume &lt;math&gt;n&lt;/math&gt; is even. Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as three nested summations.
#Simplify the summation.  Show your work.

[[2.41|Solution]]


:2.42. When you first learned to multiply numbers, you were told that &lt;math&gt;x \times y&lt;/math&gt; means adding &lt;math&gt;x&lt;/math&gt; a total of &lt;math&gt;y&lt;/math&gt; times, so &lt;math&gt;5 \times 4 = 5+5+5+5 = 20&lt;/math&gt;. What is the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers in base &lt;math&gt;b&lt;/math&gt; (people work in base 10, of course, while computers work in base 2) using the repeated addition method, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;. Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time. (Hint: how big can &lt;math&gt;y&lt;/math&gt; be as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;?)


:[[2.43]]. In grade school, you learned to multiply long numbers on a digit-by-digit basis, so that &lt;math&gt;127 \times 211 = 127 \times 1 + 127 \times 10 + 127 \times 200 = 26,397&lt;/math&gt;. Analyze the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers with this method as a function of &lt;math&gt;n&lt;/math&gt; (assume constant base size). Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time.

[[2.43|Solution]]

===Logartihms===


:2.44. Prove the following identities on logarithms:
#Prove that &lt;math&gt;\log_a (xy) = \log_a x + \log_a y&lt;/math&gt;
#Prove that &lt;math&gt;\log_a x^y = y \log_a x&lt;/math&gt;
#Prove that &lt;math&gt;\log_a x = \frac{\log_b x}{\log_b a}&lt;/math&gt;
#Prove that &lt;math&gt;x^{\log_b y} = y^{\log_b x}&lt;/math&gt;


:[[2.45]]. Show that &lt;math&gt;\lceil \lg(n+1) \rceil = \lfloor \lg n \rfloor +1&lt;/math&gt;

[[2.45|Solution]]


:2.46. Prove that that the binary representation of &lt;math&gt;n \geq 1&lt;/math&gt; has &lt;math&gt;\lfloor \lg_2 n \rfloor&lt;/math&gt; + &lt;math&gt;1&lt;/math&gt; bits.


:[[2.47]]. In one of my research papers I give a comparison-based sorting algorithm that runs in &lt;math&gt;O( n \log (\sqrt n) )&lt;/math&gt;. Given the existence of an &lt;math&gt;\Omega(n \log n)&lt;/math&gt; lower bound for sorting, how can this be possible?
 

[[2.47|Solution]]

===Interview Problems===


:2.48. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; numbers. You must pick a subset &lt;math&gt;S'&lt;/math&gt; of &lt;math&gt;k&lt;/math&gt; numbers from &lt;math&gt;S&lt;/math&gt; such that the probability of each element of &lt;math&gt;S&lt;/math&gt; occurring in &lt;math&gt;S'&lt;/math&gt; is equal (i.e., each is selected with probability &lt;math&gt;k/n&lt;/math&gt;). You may make only one pass over the numbers. What if &lt;math&gt;n&lt;/math&gt; is unknown?


:[[2.49]]. We have 1,000 data items to store on 1,000 nodes. Each node can store copies of exactly three different items. Propose a replication scheme to minimize data loss as nodes fail. What is the expected number of data entries that get lost when three random nodes fail?

[[2.49|Solution]]


:2.50. Consider the following algorithm to find the minimum element in an array of numbers &lt;math&gt;A[0, \ldots, n]&lt;/math&gt;. One extra variable &lt;math&gt;tmp&lt;/math&gt; is allocated to hold the current minimum value. Start from A[0]; "tmp" is compared against &lt;math&gt;A[1]&lt;/math&gt;, 
&lt;math&gt;A[2]&lt;/math&gt;, &lt;math&gt;\ldots&lt;/math&gt;, &lt;math&gt;A[N]&lt;/math&gt; in order. When &lt;math&gt;A[i]&lt;tmp&lt;/math&gt;, &lt;math&gt;tmp = A[i]&lt;/math&gt;. What is the expected number of times that the assignment operation &lt;math&gt;tmp = A[i]&lt;/math&gt; is performed?


:[[2.51]]. You are given ten bags of gold coins. Nine bags contain coins that each weigh 10 grams. One bag contains all false coins that weigh 1 gram less. You must identify this bag in just one weighing. You have a digital balance that reports the weight of what is placed on it.

[[2.51|Solution]]


:2.52. You have eight balls all of the same size. Seven of them weigh the same, and one of them weighs slightly more. How can you find the ball that is heavier by using a balance and only two weightings?


:[[2.53]]. Suppose we start with &lt;math&gt;n&lt;/math&gt; companies that eventually merge into one big company. How many different ways are there for them to merge?

[[2.53|Solution]]


:2.54. Six pirates must divide $300 among themselves. The division is to proceed as follows. The senior pirate proposes a way to divide the money. Then the pirates vote. If the senior pirate gets at least half the votes he wins, and that division remains. If he doesn’t, he is killed and then the next senior-most pirate gets a chance to propose the division. Now tell what will happen and why (i.e. how many pirates survive and how the division is done)? All the pirates are intelligent and the first priority is to stay alive and the next priority is to get as much money as possible.


:[[2.55]]. Reconsider the pirate problem above, where we start with only one indivisible dollar. Who gets the dollar, and how many are killed?

[[2.55|Solution]]


Back to [[Chapter List]]</text>
      <sha1>o6uylb2dpwpqg4ige9dtaq8mmrq60x7</sha1>
    </revision>
    <revision>
      <id>131</id>
      <parentid>129</parentid>
      <timestamp>2020-09-09T21:54:21Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Big Oh */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="18071">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
       ''return''(r)


:[[2.5]]. Consider the following algorithm: (the print operation prints a single asterisk; the operation &lt;math&gt;x = 2x&lt;/math&gt; doubles the value of the variable &lt;math&gt;x&lt;/math&gt;).
    ''for'' &lt;math&gt; k = 1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt;
        &lt;math&gt;x = k&lt;/math&gt;
        ''while'' (&lt;math&gt;x &lt; n&lt;/math&gt;):
           ''print'' '*'
           &lt;math&gt;x = 2x&lt;/math&gt;
:Let &lt;math&gt;f(n)&lt;/math&gt; be the complexity of this algorithm (or equivalently the number of times * is printed). Proivde correct bounds for &lt;math&gt; O(f(n))&lt;/math&gt;, and &lt;math&gt;/Theta(f(n))&lt;/math&gt;, ideally converging on &lt;math&gt;\Theta(f(n))&lt;/math&gt;.

[[2.5|Solution]]


:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. True or False?
#Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.9|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]. For each of the following functions, which of the following asymptotic bounds hold for &lt;math&gt;f(n) = O(g(n)),\Theta(g(n)),\Omega(g(n))&lt;/math&gt;?
#&lt;math&gt;f(n) = 3n^2, g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = 2n^4 - 3n^2 + 7, g(n) = n^5&lt;/math&gt;
#&lt;math&gt;f(n) = log n, g(n) = log n + 1/n&lt;/math&gt;
#&lt;math&gt;f(n) = 2^(klog n), g(n) = n^k&lt;/math&gt;
#&lt;math&gt;f(n) = 2^n, g(n) = 2^(2n)&lt;/math&gt;

[[2.11|Solution]]


:2.12. Prove that &lt;math&gt;n^3 - 3n^2-n+1 = \Theta(n^3)&lt;/math&gt;.


:2.13. Prove that &lt;math&gt;n^2 = O(2^n)&lt;/math&gt;.

[[2.13|Solution]]


:2.14. Prove or disprove: &lt;math&gt;\Theta(n^2) = \Theta(n^2+1)&lt;/math&gt;.


:[[2.15]]. Suppose you have algorithms with the five running times listed below. (Assume these are the exact running times.) How much slower do each of these inputs get when you (a) double the input size, or (b) increase the input size by one?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;

[[2.15|Solution]]


:2.16.  Suppose you have algorithms with the six running times listed below. (Assume these are the exact number of operations performed as a function of input size &lt;math&gt;n&lt;/math&gt;.)Suppose you have a computer that can perform &lt;math&gt;10^10&lt;/math&gt; operations per second. For each algorithm, what is the largest input size n that you can complete within an hour?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;  (f) &lt;math&gt;2^{2^n}&lt;/math&gt;


:[[2.17]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, give an appropriate positive constant &lt;math&gt;c&lt;/math&gt; such that &lt;math&gt;f(n) \leq c \cdot g(n)&lt;/math&gt; for all &lt;math&gt;n &gt; 1&lt;/math&gt;.
#&lt;math&gt;f(n)=n^2+n+1&lt;/math&gt;, &lt;math&gt;g(n)=2n^3&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n + n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^2&lt;/math&gt;
#&lt;math&gt;f(n)=n^2-n+1&lt;/math&gt;, &lt;math&gt;g(n)=n^2/2&lt;/math&gt;

[[2.17|Solution]]


:2.18. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n) = O(g_1(n)+g_2(n))&lt;/math&gt;.


:[[2.19]]. Prove that if &lt;math&gt;f_1(N)=\Omega(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=\Omega(g_2(n) &lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n)=\Omega(g_1(n)+g_2(n))&lt;/math&gt;.

[[2.19|Solution]]


:2.20. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n) \cdot f_2(n) = O(g_1(n) \cdot g_2(n))&lt;/math&gt;


:[[2.21]]. Prove for all &lt;math&gt;k \geq 1&lt;/math&gt; and all sets of constants &lt;math&gt;\{a_k, a_{k-1}, \ldots, a_1,a_0\} \in R&lt;/math&gt;, &lt;math&gt; a_k n^k + a_{k-1}n^{k-1}+....+a_1 n + a_0 = O(n^k)&lt;/math&gt;

[[2.21|Solution]]


:2.22. Show that for any real constants &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;, &lt;math&gt;b &gt; 0&lt;/math&gt;
&lt;center&gt;&lt;math&gt;(n + a)^b = \Omega (n^b)&lt;/math&gt;&lt;/center&gt;


:[[2.23]]. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{llll}
n &amp; 2^n &amp; n \lg n &amp; \ln n \\
n-n^3+7n^5 &amp; \lg n &amp; \sqrt n &amp; e^n \\
n^2+\lg n &amp; n^2 &amp; 2^{n-1} &amp;  \lg \lg n \\
n^3 &amp; (\lg n)^2 &amp; n! &amp; n^{1+\varepsilon} where 0&lt; \varepsilon &lt;1
\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.23|Solution]]


:2.24


:[[2.25]]

[[2.25|Solution]]


:2.26. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{lll}
\sqrt{n} &amp; n &amp; 2^n \\
n \log n &amp;  n - n^3 + 7n^5 &amp;  n^2 + \log n \\
n^2 &amp;  n^3 &amp;  \log n \\
n^{\frac{1}{3}} + \log n &amp; (\log n)^2 &amp;  n! \\
\ln n &amp; \frac{n}{\log n} &amp;  \log \log n \\
({1}/{3})^n &amp;  ({3}/{2})^n &amp;  6 \\
\end{array}&lt;/math&gt;
&lt;/center&gt;


:[[2.27]]. Find two functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt; that satisfy the following relationship. If no such &lt;math&gt;f&lt;/math&gt; and &lt;math&gt;g&lt;/math&gt; exist, write ''None.''
#&lt;math&gt;f(n)=o(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq \Theta(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n)=o(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;

[[2.27|Solution]]


:2.28. True or False?
#&lt;math&gt;2n^2+1=O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n= O(\log n)&lt;/math&gt;
#&lt;math&gt;\log n = O(\sqrt n)&lt;/math&gt;
#&lt;math&gt;n^2(1 + \sqrt n) = O(n^2 \log n)&lt;/math&gt;
#&lt;math&gt;3n^2 + \sqrt n = O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n \log n= O(n) &lt;/math&gt;
#&lt;math&gt;\log n=O(n^{-1/2})&lt;/math&gt;


:[[2.29]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, state whether &lt;math&gt;f(n)=O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;, or none of the above.
#&lt;math&gt;f(n)=n^2+3n+4&lt;/math&gt;, &lt;math&gt;g(n)=6n+7&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n&lt;/math&gt;, &lt;math&gt;g(n)=n^2-n&lt;/math&gt;
#&lt;math&gt;f(n)=2^n - n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^4+n^2&lt;/math&gt;

[[2.29|Solution]]. 


:2.30. For each of these questions, briefly explain your answer.
::(a) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
::(b) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
::(c) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
::(d) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
::(e) Is the function &lt;math&gt;f(n) = \Theta(n^2)&lt;/math&gt;, where &lt;math&gt;f(n) = 100 n^2&lt;/math&gt; for even &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;f(n) = 20 n^2 - n \log_2 n&lt;/math&gt; for odd &lt;math&gt;n&lt;/math&gt;?


:[[2.31]]. For each of the following, answer ''yes'', ''no'', or ''can't tell''. Explain your reasoning.
::(a) Is &lt;math&gt;3^n = O(2^n)&lt;/math&gt;?
::(b) Is &lt;math&gt;\log 3^n = O( \log 2^n )&lt;/math&gt;?
::(c) Is &lt;math&gt;3^n = \Omega(2^n)&lt;/math&gt;?
::(d) Is &lt;math&gt;\log 3^n = \Omega( \log 2^n )&lt;/math&gt;?

[[2.31|Solution]]


:2.32. For each of the following expressions &lt;math&gt;f(n)&lt;/math&gt; find a simple &lt;math&gt;g(n)&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n {1\over i}&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \lceil {1\over i}\rceil&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \log i&lt;/math&gt;.
#&lt;math&gt;f(n)=\log (n!)&lt;/math&gt;.


:[[2.33]]. Place the following functions into increasing asymptotic order.
::&lt;math&gt;f_1(n) = n^2\log_2n&lt;/math&gt;, &lt;math&gt;f_2(n) = n(\log_2n)^2&lt;/math&gt;, &lt;math&gt;f_3(n) = \sum_{i=0}^n 2^i&lt;/math&gt;, &lt;math&gt;f_4(n) = \log_2(\sum_{i=0}^n 2^i)&lt;/math&gt;.

[[2.33|Solution]]


:2.34. Which of the following are true?
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n-1})&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^n)&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n+1})&lt;/math&gt;.


:[[2.35]]. For each of the following functions &lt;math&gt;f&lt;/math&gt; find a simple function &lt;math&gt;g&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f_1(n)= (1000)2^n + 4^n&lt;/math&gt;.
#&lt;math&gt;f_2(n)= n + n\log n + \sqrt n&lt;/math&gt;.
#&lt;math&gt;f_3(n)= \log (n^{20}) + (\log n)^{10}&lt;/math&gt;.
#&lt;math&gt;f_4(n)= (0.99)^n + n^{100}.&lt;/math&gt;

[[2.35|Solution]]


:2.36. For each pair of expressions &lt;math&gt;(A,B)&lt;/math&gt; below, indicate whether &lt;math&gt;A&lt;/math&gt; is &lt;math&gt;O&lt;/math&gt;, &lt;math&gt;o&lt;/math&gt;, &lt;math&gt;\Omega&lt;/math&gt;, &lt;math&gt;\omega&lt;/math&gt;, or &lt;math&gt;\Theta&lt;/math&gt; of &lt;math&gt;B&lt;/math&gt;.  Note that zero, one or more of these relations may hold for a given pair; list all correct ones.
&lt;br&gt;&lt;center&gt;&lt;math&gt;
\begin{array}{lcc}
        &amp; A                     &amp; B \\
(a)     &amp; n^{100}               &amp; 2^n \\
(b)     &amp; (\lg n)^{12}         &amp; \sqrt{n} \\
(c)     &amp; \sqrt{n}              &amp; n^{\cos (\pi n/8)} \\
(d)     &amp; 10^n                  &amp; 100^n \\
(e)     &amp; n^{\lg n}            &amp; (\lg n)^n \\
(f)     &amp; \lg{(n!)}            &amp; n \lg n
\end{array}
&lt;/math&gt;&lt;/center&gt;

===Summations===


:[[2.37]]. Find an expression for the sum of the &lt;math&gt;i&lt;/math&gt;th row of the following triangle, and prove its correctness. Each entry is the sum of the three entries directly above it. All non existing entries are considered 0.
&lt;center&gt;
&lt;math&gt;\begin{array}{ccccccccc}
&amp;&amp;&amp;&amp;1&amp;&amp;&amp;&amp; \\
&amp;&amp;&amp;1&amp;1&amp;1&amp;&amp;&amp;\\
&amp;&amp;1&amp;2&amp;3&amp;2&amp;1&amp;&amp;\\
&amp;1&amp;3&amp;6&amp;7&amp;6&amp;3&amp;1&amp;\\
1&amp;4&amp;10&amp;16&amp;19&amp;16&amp;10&amp;4&amp;1\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.37|Solution]]


:2.38. Assume that Christmas has &lt;math&gt;n&lt;/math&gt; days. Exactly how many presents did my ''true love'' send me? (Do some research if you do not understand this question.)


:[[2.39]]

[[2.39|Solution]]


:2.40. Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n do
      for j=i to 2*i do
         output ''foobar''
&lt;/tt&gt;
:Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as a summation (actually two nested summations).
#Simplify the summation.  Show your work.


:[[2.41]].Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n/2 do
      for j=i to n-i do
         for k=1 to j do
            output ''foobar''
&lt;/tt&gt;
:Assume &lt;math&gt;n&lt;/math&gt; is even. Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as three nested summations.
#Simplify the summation.  Show your work.

[[2.41|Solution]]


:2.42. When you first learned to multiply numbers, you were told that &lt;math&gt;x \times y&lt;/math&gt; means adding &lt;math&gt;x&lt;/math&gt; a total of &lt;math&gt;y&lt;/math&gt; times, so &lt;math&gt;5 \times 4 = 5+5+5+5 = 20&lt;/math&gt;. What is the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers in base &lt;math&gt;b&lt;/math&gt; (people work in base 10, of course, while computers work in base 2) using the repeated addition method, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;. Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time. (Hint: how big can &lt;math&gt;y&lt;/math&gt; be as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;?)


:[[2.43]]. In grade school, you learned to multiply long numbers on a digit-by-digit basis, so that &lt;math&gt;127 \times 211 = 127 \times 1 + 127 \times 10 + 127 \times 200 = 26,397&lt;/math&gt;. Analyze the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers with this method as a function of &lt;math&gt;n&lt;/math&gt; (assume constant base size). Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time.

[[2.43|Solution]]

===Logartihms===


:2.44. Prove the following identities on logarithms:
#Prove that &lt;math&gt;\log_a (xy) = \log_a x + \log_a y&lt;/math&gt;
#Prove that &lt;math&gt;\log_a x^y = y \log_a x&lt;/math&gt;
#Prove that &lt;math&gt;\log_a x = \frac{\log_b x}{\log_b a}&lt;/math&gt;
#Prove that &lt;math&gt;x^{\log_b y} = y^{\log_b x}&lt;/math&gt;


:[[2.45]]. Show that &lt;math&gt;\lceil \lg(n+1) \rceil = \lfloor \lg n \rfloor +1&lt;/math&gt;

[[2.45|Solution]]


:2.46. Prove that that the binary representation of &lt;math&gt;n \geq 1&lt;/math&gt; has &lt;math&gt;\lfloor \lg_2 n \rfloor&lt;/math&gt; + &lt;math&gt;1&lt;/math&gt; bits.


:[[2.47]]. In one of my research papers I give a comparison-based sorting algorithm that runs in &lt;math&gt;O( n \log (\sqrt n) )&lt;/math&gt;. Given the existence of an &lt;math&gt;\Omega(n \log n)&lt;/math&gt; lower bound for sorting, how can this be possible?
 

[[2.47|Solution]]

===Interview Problems===


:2.48. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; numbers. You must pick a subset &lt;math&gt;S'&lt;/math&gt; of &lt;math&gt;k&lt;/math&gt; numbers from &lt;math&gt;S&lt;/math&gt; such that the probability of each element of &lt;math&gt;S&lt;/math&gt; occurring in &lt;math&gt;S'&lt;/math&gt; is equal (i.e., each is selected with probability &lt;math&gt;k/n&lt;/math&gt;). You may make only one pass over the numbers. What if &lt;math&gt;n&lt;/math&gt; is unknown?


:[[2.49]]. We have 1,000 data items to store on 1,000 nodes. Each node can store copies of exactly three different items. Propose a replication scheme to minimize data loss as nodes fail. What is the expected number of data entries that get lost when three random nodes fail?

[[2.49|Solution]]


:2.50. Consider the following algorithm to find the minimum element in an array of numbers &lt;math&gt;A[0, \ldots, n]&lt;/math&gt;. One extra variable &lt;math&gt;tmp&lt;/math&gt; is allocated to hold the current minimum value. Start from A[0]; "tmp" is compared against &lt;math&gt;A[1]&lt;/math&gt;, 
&lt;math&gt;A[2]&lt;/math&gt;, &lt;math&gt;\ldots&lt;/math&gt;, &lt;math&gt;A[N]&lt;/math&gt; in order. When &lt;math&gt;A[i]&lt;tmp&lt;/math&gt;, &lt;math&gt;tmp = A[i]&lt;/math&gt;. What is the expected number of times that the assignment operation &lt;math&gt;tmp = A[i]&lt;/math&gt; is performed?


:[[2.51]]. You are given ten bags of gold coins. Nine bags contain coins that each weigh 10 grams. One bag contains all false coins that weigh 1 gram less. You must identify this bag in just one weighing. You have a digital balance that reports the weight of what is placed on it.

[[2.51|Solution]]


:2.52. You have eight balls all of the same size. Seven of them weigh the same, and one of them weighs slightly more. How can you find the ball that is heavier by using a balance and only two weightings?


:[[2.53]]. Suppose we start with &lt;math&gt;n&lt;/math&gt; companies that eventually merge into one big company. How many different ways are there for them to merge?

[[2.53|Solution]]


:2.54. Six pirates must divide $300 among themselves. The division is to proceed as follows. The senior pirate proposes a way to divide the money. Then the pirates vote. If the senior pirate gets at least half the votes he wins, and that division remains. If he doesn’t, he is killed and then the next senior-most pirate gets a chance to propose the division. Now tell what will happen and why (i.e. how many pirates survive and how the division is done)? All the pirates are intelligent and the first priority is to stay alive and the next priority is to get as much money as possible.


:[[2.55]]. Reconsider the pirate problem above, where we start with only one indivisible dollar. Who gets the dollar, and how many are killed?

[[2.55|Solution]]


Back to [[Chapter List]]</text>
      <sha1>7i7xnby9yfe19oeq7dmdbminqr06g9r</sha1>
    </revision>
    <revision>
      <id>132</id>
      <parentid>131</parentid>
      <timestamp>2020-09-10T19:29:51Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Big Oh */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="18079">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
       ''return''(r)


:[[2.5]]. Consider the following algorithm: (the print operation prints a single asterisk; the operation &lt;math&gt;x = 2x&lt;/math&gt; doubles the value of the variable &lt;math&gt;x&lt;/math&gt;).
    ''for'' &lt;math&gt; k = 1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt;
        &lt;math&gt;x = k&lt;/math&gt;
        ''while'' (&lt;math&gt;x &lt; n&lt;/math&gt;):
           ''print'' '*'
           &lt;math&gt;x = 2x&lt;/math&gt;
:Let &lt;math&gt;f(n)&lt;/math&gt; be the complexity of this algorithm (or equivalently the number of times * is printed). Proivde correct bounds for &lt;math&gt; O(f(n))&lt;/math&gt;, and &lt;math&gt;/Theta(f(n))&lt;/math&gt;, ideally converging on &lt;math&gt;\Theta(f(n))&lt;/math&gt;.

[[2.5|Solution]]


:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. True or False?
#Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.9|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]. For each of the following functions, which of the following asymptotic bounds hold for &lt;math&gt;f(n) = O(g(n)),\Theta(g(n)),\Omega(g(n))&lt;/math&gt;?
#&lt;math&gt;f(n) = 3n^2, g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = 2n^4 - 3n^2 + 7, g(n) = n^5&lt;/math&gt;
#&lt;math&gt;f(n) = log n, g(n) = log n + 1/n&lt;/math&gt;
#&lt;math&gt;f(n) = 2&lt;sup&gt;klog n&lt;/sup&gt;, g(n) = n^k&lt;/math&gt;
#&lt;math&gt;f(n) = 2^n, g(n) = 2^(2n)&lt;/math&gt;

[[2.11|Solution]]


:2.12. Prove that &lt;math&gt;n^3 - 3n^2-n+1 = \Theta(n^3)&lt;/math&gt;.


:2.13. Prove that &lt;math&gt;n^2 = O(2^n)&lt;/math&gt;.

[[2.13|Solution]]


:2.14. Prove or disprove: &lt;math&gt;\Theta(n^2) = \Theta(n^2+1)&lt;/math&gt;.


:[[2.15]]. Suppose you have algorithms with the five running times listed below. (Assume these are the exact running times.) How much slower do each of these inputs get when you (a) double the input size, or (b) increase the input size by one?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;

[[2.15|Solution]]


:2.16.  Suppose you have algorithms with the six running times listed below. (Assume these are the exact number of operations performed as a function of input size &lt;math&gt;n&lt;/math&gt;.)Suppose you have a computer that can perform &lt;math&gt;10^10&lt;/math&gt; operations per second. For each algorithm, what is the largest input size n that you can complete within an hour?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;  (f) &lt;math&gt;2^{2^n}&lt;/math&gt;


:[[2.17]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, give an appropriate positive constant &lt;math&gt;c&lt;/math&gt; such that &lt;math&gt;f(n) \leq c \cdot g(n)&lt;/math&gt; for all &lt;math&gt;n &gt; 1&lt;/math&gt;.
#&lt;math&gt;f(n)=n^2+n+1&lt;/math&gt;, &lt;math&gt;g(n)=2n^3&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n + n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^2&lt;/math&gt;
#&lt;math&gt;f(n)=n^2-n+1&lt;/math&gt;, &lt;math&gt;g(n)=n^2/2&lt;/math&gt;

[[2.17|Solution]]


:2.18. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n) = O(g_1(n)+g_2(n))&lt;/math&gt;.


:[[2.19]]. Prove that if &lt;math&gt;f_1(N)=\Omega(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=\Omega(g_2(n) &lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n)=\Omega(g_1(n)+g_2(n))&lt;/math&gt;.

[[2.19|Solution]]


:2.20. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n) \cdot f_2(n) = O(g_1(n) \cdot g_2(n))&lt;/math&gt;


:[[2.21]]. Prove for all &lt;math&gt;k \geq 1&lt;/math&gt; and all sets of constants &lt;math&gt;\{a_k, a_{k-1}, \ldots, a_1,a_0\} \in R&lt;/math&gt;, &lt;math&gt; a_k n^k + a_{k-1}n^{k-1}+....+a_1 n + a_0 = O(n^k)&lt;/math&gt;

[[2.21|Solution]]


:2.22. Show that for any real constants &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;, &lt;math&gt;b &gt; 0&lt;/math&gt;
&lt;center&gt;&lt;math&gt;(n + a)^b = \Omega (n^b)&lt;/math&gt;&lt;/center&gt;


:[[2.23]]. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{llll}
n &amp; 2^n &amp; n \lg n &amp; \ln n \\
n-n^3+7n^5 &amp; \lg n &amp; \sqrt n &amp; e^n \\
n^2+\lg n &amp; n^2 &amp; 2^{n-1} &amp;  \lg \lg n \\
n^3 &amp; (\lg n)^2 &amp; n! &amp; n^{1+\varepsilon} where 0&lt; \varepsilon &lt;1
\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.23|Solution]]


:2.24


:[[2.25]]

[[2.25|Solution]]


:2.26. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{lll}
\sqrt{n} &amp; n &amp; 2^n \\
n \log n &amp;  n - n^3 + 7n^5 &amp;  n^2 + \log n \\
n^2 &amp;  n^3 &amp;  \log n \\
n^{\frac{1}{3}} + \log n &amp; (\log n)^2 &amp;  n! \\
\ln n &amp; \frac{n}{\log n} &amp;  \log \log n \\
({1}/{3})^n &amp;  ({3}/{2})^n &amp;  6 \\
\end{array}&lt;/math&gt;
&lt;/center&gt;


:[[2.27]]. Find two functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt; that satisfy the following relationship. If no such &lt;math&gt;f&lt;/math&gt; and &lt;math&gt;g&lt;/math&gt; exist, write ''None.''
#&lt;math&gt;f(n)=o(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq \Theta(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n)=o(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;

[[2.27|Solution]]


:2.28. True or False?
#&lt;math&gt;2n^2+1=O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n= O(\log n)&lt;/math&gt;
#&lt;math&gt;\log n = O(\sqrt n)&lt;/math&gt;
#&lt;math&gt;n^2(1 + \sqrt n) = O(n^2 \log n)&lt;/math&gt;
#&lt;math&gt;3n^2 + \sqrt n = O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n \log n= O(n) &lt;/math&gt;
#&lt;math&gt;\log n=O(n^{-1/2})&lt;/math&gt;


:[[2.29]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, state whether &lt;math&gt;f(n)=O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;, or none of the above.
#&lt;math&gt;f(n)=n^2+3n+4&lt;/math&gt;, &lt;math&gt;g(n)=6n+7&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n&lt;/math&gt;, &lt;math&gt;g(n)=n^2-n&lt;/math&gt;
#&lt;math&gt;f(n)=2^n - n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^4+n^2&lt;/math&gt;

[[2.29|Solution]]. 


:2.30. For each of these questions, briefly explain your answer.
::(a) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
::(b) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
::(c) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
::(d) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
::(e) Is the function &lt;math&gt;f(n) = \Theta(n^2)&lt;/math&gt;, where &lt;math&gt;f(n) = 100 n^2&lt;/math&gt; for even &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;f(n) = 20 n^2 - n \log_2 n&lt;/math&gt; for odd &lt;math&gt;n&lt;/math&gt;?


:[[2.31]]. For each of the following, answer ''yes'', ''no'', or ''can't tell''. Explain your reasoning.
::(a) Is &lt;math&gt;3^n = O(2^n)&lt;/math&gt;?
::(b) Is &lt;math&gt;\log 3^n = O( \log 2^n )&lt;/math&gt;?
::(c) Is &lt;math&gt;3^n = \Omega(2^n)&lt;/math&gt;?
::(d) Is &lt;math&gt;\log 3^n = \Omega( \log 2^n )&lt;/math&gt;?

[[2.31|Solution]]


:2.32. For each of the following expressions &lt;math&gt;f(n)&lt;/math&gt; find a simple &lt;math&gt;g(n)&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n {1\over i}&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \lceil {1\over i}\rceil&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \log i&lt;/math&gt;.
#&lt;math&gt;f(n)=\log (n!)&lt;/math&gt;.


:[[2.33]]. Place the following functions into increasing asymptotic order.
::&lt;math&gt;f_1(n) = n^2\log_2n&lt;/math&gt;, &lt;math&gt;f_2(n) = n(\log_2n)^2&lt;/math&gt;, &lt;math&gt;f_3(n) = \sum_{i=0}^n 2^i&lt;/math&gt;, &lt;math&gt;f_4(n) = \log_2(\sum_{i=0}^n 2^i)&lt;/math&gt;.

[[2.33|Solution]]


:2.34. Which of the following are true?
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n-1})&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^n)&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n+1})&lt;/math&gt;.


:[[2.35]]. For each of the following functions &lt;math&gt;f&lt;/math&gt; find a simple function &lt;math&gt;g&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f_1(n)= (1000)2^n + 4^n&lt;/math&gt;.
#&lt;math&gt;f_2(n)= n + n\log n + \sqrt n&lt;/math&gt;.
#&lt;math&gt;f_3(n)= \log (n^{20}) + (\log n)^{10}&lt;/math&gt;.
#&lt;math&gt;f_4(n)= (0.99)^n + n^{100}.&lt;/math&gt;

[[2.35|Solution]]


:2.36. For each pair of expressions &lt;math&gt;(A,B)&lt;/math&gt; below, indicate whether &lt;math&gt;A&lt;/math&gt; is &lt;math&gt;O&lt;/math&gt;, &lt;math&gt;o&lt;/math&gt;, &lt;math&gt;\Omega&lt;/math&gt;, &lt;math&gt;\omega&lt;/math&gt;, or &lt;math&gt;\Theta&lt;/math&gt; of &lt;math&gt;B&lt;/math&gt;.  Note that zero, one or more of these relations may hold for a given pair; list all correct ones.
&lt;br&gt;&lt;center&gt;&lt;math&gt;
\begin{array}{lcc}
        &amp; A                     &amp; B \\
(a)     &amp; n^{100}               &amp; 2^n \\
(b)     &amp; (\lg n)^{12}         &amp; \sqrt{n} \\
(c)     &amp; \sqrt{n}              &amp; n^{\cos (\pi n/8)} \\
(d)     &amp; 10^n                  &amp; 100^n \\
(e)     &amp; n^{\lg n}            &amp; (\lg n)^n \\
(f)     &amp; \lg{(n!)}            &amp; n \lg n
\end{array}
&lt;/math&gt;&lt;/center&gt;

===Summations===


:[[2.37]]. Find an expression for the sum of the &lt;math&gt;i&lt;/math&gt;th row of the following triangle, and prove its correctness. Each entry is the sum of the three entries directly above it. All non existing entries are considered 0.
&lt;center&gt;
&lt;math&gt;\begin{array}{ccccccccc}
&amp;&amp;&amp;&amp;1&amp;&amp;&amp;&amp; \\
&amp;&amp;&amp;1&amp;1&amp;1&amp;&amp;&amp;\\
&amp;&amp;1&amp;2&amp;3&amp;2&amp;1&amp;&amp;\\
&amp;1&amp;3&amp;6&amp;7&amp;6&amp;3&amp;1&amp;\\
1&amp;4&amp;10&amp;16&amp;19&amp;16&amp;10&amp;4&amp;1\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.37|Solution]]


:2.38. Assume that Christmas has &lt;math&gt;n&lt;/math&gt; days. Exactly how many presents did my ''true love'' send me? (Do some research if you do not understand this question.)


:[[2.39]]

[[2.39|Solution]]


:2.40. Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n do
      for j=i to 2*i do
         output ''foobar''
&lt;/tt&gt;
:Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as a summation (actually two nested summations).
#Simplify the summation.  Show your work.


:[[2.41]].Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n/2 do
      for j=i to n-i do
         for k=1 to j do
            output ''foobar''
&lt;/tt&gt;
:Assume &lt;math&gt;n&lt;/math&gt; is even. Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as three nested summations.
#Simplify the summation.  Show your work.

[[2.41|Solution]]


:2.42. When you first learned to multiply numbers, you were told that &lt;math&gt;x \times y&lt;/math&gt; means adding &lt;math&gt;x&lt;/math&gt; a total of &lt;math&gt;y&lt;/math&gt; times, so &lt;math&gt;5 \times 4 = 5+5+5+5 = 20&lt;/math&gt;. What is the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers in base &lt;math&gt;b&lt;/math&gt; (people work in base 10, of course, while computers work in base 2) using the repeated addition method, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;. Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time. (Hint: how big can &lt;math&gt;y&lt;/math&gt; be as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;?)


:[[2.43]]. In grade school, you learned to multiply long numbers on a digit-by-digit basis, so that &lt;math&gt;127 \times 211 = 127 \times 1 + 127 \times 10 + 127 \times 200 = 26,397&lt;/math&gt;. Analyze the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers with this method as a function of &lt;math&gt;n&lt;/math&gt; (assume constant base size). Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time.

[[2.43|Solution]]

===Logartihms===


:2.44. Prove the following identities on logarithms:
#Prove that &lt;math&gt;\log_a (xy) = \log_a x + \log_a y&lt;/math&gt;
#Prove that &lt;math&gt;\log_a x^y = y \log_a x&lt;/math&gt;
#Prove that &lt;math&gt;\log_a x = \frac{\log_b x}{\log_b a}&lt;/math&gt;
#Prove that &lt;math&gt;x^{\log_b y} = y^{\log_b x}&lt;/math&gt;


:[[2.45]]. Show that &lt;math&gt;\lceil \lg(n+1) \rceil = \lfloor \lg n \rfloor +1&lt;/math&gt;

[[2.45|Solution]]


:2.46. Prove that that the binary representation of &lt;math&gt;n \geq 1&lt;/math&gt; has &lt;math&gt;\lfloor \lg_2 n \rfloor&lt;/math&gt; + &lt;math&gt;1&lt;/math&gt; bits.


:[[2.47]]. In one of my research papers I give a comparison-based sorting algorithm that runs in &lt;math&gt;O( n \log (\sqrt n) )&lt;/math&gt;. Given the existence of an &lt;math&gt;\Omega(n \log n)&lt;/math&gt; lower bound for sorting, how can this be possible?
 

[[2.47|Solution]]

===Interview Problems===


:2.48. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; numbers. You must pick a subset &lt;math&gt;S'&lt;/math&gt; of &lt;math&gt;k&lt;/math&gt; numbers from &lt;math&gt;S&lt;/math&gt; such that the probability of each element of &lt;math&gt;S&lt;/math&gt; occurring in &lt;math&gt;S'&lt;/math&gt; is equal (i.e., each is selected with probability &lt;math&gt;k/n&lt;/math&gt;). You may make only one pass over the numbers. What if &lt;math&gt;n&lt;/math&gt; is unknown?


:[[2.49]]. We have 1,000 data items to store on 1,000 nodes. Each node can store copies of exactly three different items. Propose a replication scheme to minimize data loss as nodes fail. What is the expected number of data entries that get lost when three random nodes fail?

[[2.49|Solution]]


:2.50. Consider the following algorithm to find the minimum element in an array of numbers &lt;math&gt;A[0, \ldots, n]&lt;/math&gt;. One extra variable &lt;math&gt;tmp&lt;/math&gt; is allocated to hold the current minimum value. Start from A[0]; "tmp" is compared against &lt;math&gt;A[1]&lt;/math&gt;, 
&lt;math&gt;A[2]&lt;/math&gt;, &lt;math&gt;\ldots&lt;/math&gt;, &lt;math&gt;A[N]&lt;/math&gt; in order. When &lt;math&gt;A[i]&lt;tmp&lt;/math&gt;, &lt;math&gt;tmp = A[i]&lt;/math&gt;. What is the expected number of times that the assignment operation &lt;math&gt;tmp = A[i]&lt;/math&gt; is performed?


:[[2.51]]. You are given ten bags of gold coins. Nine bags contain coins that each weigh 10 grams. One bag contains all false coins that weigh 1 gram less. You must identify this bag in just one weighing. You have a digital balance that reports the weight of what is placed on it.

[[2.51|Solution]]


:2.52. You have eight balls all of the same size. Seven of them weigh the same, and one of them weighs slightly more. How can you find the ball that is heavier by using a balance and only two weightings?


:[[2.53]]. Suppose we start with &lt;math&gt;n&lt;/math&gt; companies that eventually merge into one big company. How many different ways are there for them to merge?

[[2.53|Solution]]


:2.54. Six pirates must divide $300 among themselves. The division is to proceed as follows. The senior pirate proposes a way to divide the money. Then the pirates vote. If the senior pirate gets at least half the votes he wins, and that division remains. If he doesn’t, he is killed and then the next senior-most pirate gets a chance to propose the division. Now tell what will happen and why (i.e. how many pirates survive and how the division is done)? All the pirates are intelligent and the first priority is to stay alive and the next priority is to get as much money as possible.


:[[2.55]]. Reconsider the pirate problem above, where we start with only one indivisible dollar. Who gets the dollar, and how many are killed?

[[2.55|Solution]]


Back to [[Chapter List]]</text>
      <sha1>etalgaee9hxgp3dhzky3pcbl2ohp9hr</sha1>
    </revision>
    <revision>
      <id>133</id>
      <parentid>132</parentid>
      <timestamp>2020-09-10T19:34:56Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Big Oh */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="18071">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
       ''return''(r)


:[[2.5]]. Consider the following algorithm: (the print operation prints a single asterisk; the operation &lt;math&gt;x = 2x&lt;/math&gt; doubles the value of the variable &lt;math&gt;x&lt;/math&gt;).
    ''for'' &lt;math&gt; k = 1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt;
        &lt;math&gt;x = k&lt;/math&gt;
        ''while'' (&lt;math&gt;x &lt; n&lt;/math&gt;):
           ''print'' '*'
           &lt;math&gt;x = 2x&lt;/math&gt;
:Let &lt;math&gt;f(n)&lt;/math&gt; be the complexity of this algorithm (or equivalently the number of times * is printed). Proivde correct bounds for &lt;math&gt; O(f(n))&lt;/math&gt;, and &lt;math&gt;/Theta(f(n))&lt;/math&gt;, ideally converging on &lt;math&gt;\Theta(f(n))&lt;/math&gt;.

[[2.5|Solution]]


:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. True or False?
#Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.9|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]. For each of the following functions, which of the following asymptotic bounds hold for &lt;math&gt;f(n) = O(g(n)),\Theta(g(n)),\Omega(g(n))&lt;/math&gt;?
#&lt;math&gt;f(n) = 3n^2, g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = 2n^4 - 3n^2 + 7, g(n) = n^5&lt;/math&gt;
#&lt;math&gt;f(n) = log n, g(n) = log n + 1/n&lt;/math&gt;
#&lt;math&gt;f(n) = 2^{klog n}, g(n) = n^k&lt;/math&gt;
#&lt;math&gt;f(n) = 2^n, g(n) = 2^{2n}&lt;/math&gt;

[[2.11|Solution]]


:2.12. Prove that &lt;math&gt;n^3 - 3n^2-n+1 = \Theta(n^3)&lt;/math&gt;.


:2.13. Prove that &lt;math&gt;n^2 = O(2^n)&lt;/math&gt;.

[[2.13|Solution]]


:2.14. Prove or disprove: &lt;math&gt;\Theta(n^2) = \Theta(n^2+1)&lt;/math&gt;.


:[[2.15]]. Suppose you have algorithms with the five running times listed below. (Assume these are the exact running times.) How much slower do each of these inputs get when you (a) double the input size, or (b) increase the input size by one?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;

[[2.15|Solution]]


:2.16.  Suppose you have algorithms with the six running times listed below. (Assume these are the exact number of operations performed as a function of input size &lt;math&gt;n&lt;/math&gt;.)Suppose you have a computer that can perform &lt;math&gt;10^10&lt;/math&gt; operations per second. For each algorithm, what is the largest input size n that you can complete within an hour?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;  (f) &lt;math&gt;2^{2^n}&lt;/math&gt;


:[[2.17]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, give an appropriate positive constant &lt;math&gt;c&lt;/math&gt; such that &lt;math&gt;f(n) \leq c \cdot g(n)&lt;/math&gt; for all &lt;math&gt;n &gt; 1&lt;/math&gt;.
#&lt;math&gt;f(n)=n^2+n+1&lt;/math&gt;, &lt;math&gt;g(n)=2n^3&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n + n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^2&lt;/math&gt;
#&lt;math&gt;f(n)=n^2-n+1&lt;/math&gt;, &lt;math&gt;g(n)=n^2/2&lt;/math&gt;

[[2.17|Solution]]


:2.18. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n) = O(g_1(n)+g_2(n))&lt;/math&gt;.


:[[2.19]]. Prove that if &lt;math&gt;f_1(N)=\Omega(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=\Omega(g_2(n) &lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n)=\Omega(g_1(n)+g_2(n))&lt;/math&gt;.

[[2.19|Solution]]


:2.20. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n) \cdot f_2(n) = O(g_1(n) \cdot g_2(n))&lt;/math&gt;


:[[2.21]]. Prove for all &lt;math&gt;k \geq 1&lt;/math&gt; and all sets of constants &lt;math&gt;\{a_k, a_{k-1}, \ldots, a_1,a_0\} \in R&lt;/math&gt;, &lt;math&gt; a_k n^k + a_{k-1}n^{k-1}+....+a_1 n + a_0 = O(n^k)&lt;/math&gt;

[[2.21|Solution]]


:2.22. Show that for any real constants &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;, &lt;math&gt;b &gt; 0&lt;/math&gt;
&lt;center&gt;&lt;math&gt;(n + a)^b = \Omega (n^b)&lt;/math&gt;&lt;/center&gt;


:[[2.23]]. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{llll}
n &amp; 2^n &amp; n \lg n &amp; \ln n \\
n-n^3+7n^5 &amp; \lg n &amp; \sqrt n &amp; e^n \\
n^2+\lg n &amp; n^2 &amp; 2^{n-1} &amp;  \lg \lg n \\
n^3 &amp; (\lg n)^2 &amp; n! &amp; n^{1+\varepsilon} where 0&lt; \varepsilon &lt;1
\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.23|Solution]]


:2.24


:[[2.25]]

[[2.25|Solution]]


:2.26. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{lll}
\sqrt{n} &amp; n &amp; 2^n \\
n \log n &amp;  n - n^3 + 7n^5 &amp;  n^2 + \log n \\
n^2 &amp;  n^3 &amp;  \log n \\
n^{\frac{1}{3}} + \log n &amp; (\log n)^2 &amp;  n! \\
\ln n &amp; \frac{n}{\log n} &amp;  \log \log n \\
({1}/{3})^n &amp;  ({3}/{2})^n &amp;  6 \\
\end{array}&lt;/math&gt;
&lt;/center&gt;


:[[2.27]]. Find two functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt; that satisfy the following relationship. If no such &lt;math&gt;f&lt;/math&gt; and &lt;math&gt;g&lt;/math&gt; exist, write ''None.''
#&lt;math&gt;f(n)=o(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq \Theta(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n)=o(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;

[[2.27|Solution]]


:2.28. True or False?
#&lt;math&gt;2n^2+1=O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n= O(\log n)&lt;/math&gt;
#&lt;math&gt;\log n = O(\sqrt n)&lt;/math&gt;
#&lt;math&gt;n^2(1 + \sqrt n) = O(n^2 \log n)&lt;/math&gt;
#&lt;math&gt;3n^2 + \sqrt n = O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n \log n= O(n) &lt;/math&gt;
#&lt;math&gt;\log n=O(n^{-1/2})&lt;/math&gt;


:[[2.29]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, state whether &lt;math&gt;f(n)=O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;, or none of the above.
#&lt;math&gt;f(n)=n^2+3n+4&lt;/math&gt;, &lt;math&gt;g(n)=6n+7&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n&lt;/math&gt;, &lt;math&gt;g(n)=n^2-n&lt;/math&gt;
#&lt;math&gt;f(n)=2^n - n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^4+n^2&lt;/math&gt;

[[2.29|Solution]]. 


:2.30. For each of these questions, briefly explain your answer.
::(a) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
::(b) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
::(c) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
::(d) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
::(e) Is the function &lt;math&gt;f(n) = \Theta(n^2)&lt;/math&gt;, where &lt;math&gt;f(n) = 100 n^2&lt;/math&gt; for even &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;f(n) = 20 n^2 - n \log_2 n&lt;/math&gt; for odd &lt;math&gt;n&lt;/math&gt;?


:[[2.31]]. For each of the following, answer ''yes'', ''no'', or ''can't tell''. Explain your reasoning.
::(a) Is &lt;math&gt;3^n = O(2^n)&lt;/math&gt;?
::(b) Is &lt;math&gt;\log 3^n = O( \log 2^n )&lt;/math&gt;?
::(c) Is &lt;math&gt;3^n = \Omega(2^n)&lt;/math&gt;?
::(d) Is &lt;math&gt;\log 3^n = \Omega( \log 2^n )&lt;/math&gt;?

[[2.31|Solution]]


:2.32. For each of the following expressions &lt;math&gt;f(n)&lt;/math&gt; find a simple &lt;math&gt;g(n)&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n {1\over i}&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \lceil {1\over i}\rceil&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \log i&lt;/math&gt;.
#&lt;math&gt;f(n)=\log (n!)&lt;/math&gt;.


:[[2.33]]. Place the following functions into increasing asymptotic order.
::&lt;math&gt;f_1(n) = n^2\log_2n&lt;/math&gt;, &lt;math&gt;f_2(n) = n(\log_2n)^2&lt;/math&gt;, &lt;math&gt;f_3(n) = \sum_{i=0}^n 2^i&lt;/math&gt;, &lt;math&gt;f_4(n) = \log_2(\sum_{i=0}^n 2^i)&lt;/math&gt;.

[[2.33|Solution]]


:2.34. Which of the following are true?
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n-1})&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^n)&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n+1})&lt;/math&gt;.


:[[2.35]]. For each of the following functions &lt;math&gt;f&lt;/math&gt; find a simple function &lt;math&gt;g&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f_1(n)= (1000)2^n + 4^n&lt;/math&gt;.
#&lt;math&gt;f_2(n)= n + n\log n + \sqrt n&lt;/math&gt;.
#&lt;math&gt;f_3(n)= \log (n^{20}) + (\log n)^{10}&lt;/math&gt;.
#&lt;math&gt;f_4(n)= (0.99)^n + n^{100}.&lt;/math&gt;

[[2.35|Solution]]


:2.36. For each pair of expressions &lt;math&gt;(A,B)&lt;/math&gt; below, indicate whether &lt;math&gt;A&lt;/math&gt; is &lt;math&gt;O&lt;/math&gt;, &lt;math&gt;o&lt;/math&gt;, &lt;math&gt;\Omega&lt;/math&gt;, &lt;math&gt;\omega&lt;/math&gt;, or &lt;math&gt;\Theta&lt;/math&gt; of &lt;math&gt;B&lt;/math&gt;.  Note that zero, one or more of these relations may hold for a given pair; list all correct ones.
&lt;br&gt;&lt;center&gt;&lt;math&gt;
\begin{array}{lcc}
        &amp; A                     &amp; B \\
(a)     &amp; n^{100}               &amp; 2^n \\
(b)     &amp; (\lg n)^{12}         &amp; \sqrt{n} \\
(c)     &amp; \sqrt{n}              &amp; n^{\cos (\pi n/8)} \\
(d)     &amp; 10^n                  &amp; 100^n \\
(e)     &amp; n^{\lg n}            &amp; (\lg n)^n \\
(f)     &amp; \lg{(n!)}            &amp; n \lg n
\end{array}
&lt;/math&gt;&lt;/center&gt;

===Summations===


:[[2.37]]. Find an expression for the sum of the &lt;math&gt;i&lt;/math&gt;th row of the following triangle, and prove its correctness. Each entry is the sum of the three entries directly above it. All non existing entries are considered 0.
&lt;center&gt;
&lt;math&gt;\begin{array}{ccccccccc}
&amp;&amp;&amp;&amp;1&amp;&amp;&amp;&amp; \\
&amp;&amp;&amp;1&amp;1&amp;1&amp;&amp;&amp;\\
&amp;&amp;1&amp;2&amp;3&amp;2&amp;1&amp;&amp;\\
&amp;1&amp;3&amp;6&amp;7&amp;6&amp;3&amp;1&amp;\\
1&amp;4&amp;10&amp;16&amp;19&amp;16&amp;10&amp;4&amp;1\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.37|Solution]]


:2.38. Assume that Christmas has &lt;math&gt;n&lt;/math&gt; days. Exactly how many presents did my ''true love'' send me? (Do some research if you do not understand this question.)


:[[2.39]]

[[2.39|Solution]]


:2.40. Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n do
      for j=i to 2*i do
         output ''foobar''
&lt;/tt&gt;
:Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as a summation (actually two nested summations).
#Simplify the summation.  Show your work.


:[[2.41]].Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n/2 do
      for j=i to n-i do
         for k=1 to j do
            output ''foobar''
&lt;/tt&gt;
:Assume &lt;math&gt;n&lt;/math&gt; is even. Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as three nested summations.
#Simplify the summation.  Show your work.

[[2.41|Solution]]


:2.42. When you first learned to multiply numbers, you were told that &lt;math&gt;x \times y&lt;/math&gt; means adding &lt;math&gt;x&lt;/math&gt; a total of &lt;math&gt;y&lt;/math&gt; times, so &lt;math&gt;5 \times 4 = 5+5+5+5 = 20&lt;/math&gt;. What is the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers in base &lt;math&gt;b&lt;/math&gt; (people work in base 10, of course, while computers work in base 2) using the repeated addition method, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;. Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time. (Hint: how big can &lt;math&gt;y&lt;/math&gt; be as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;?)


:[[2.43]]. In grade school, you learned to multiply long numbers on a digit-by-digit basis, so that &lt;math&gt;127 \times 211 = 127 \times 1 + 127 \times 10 + 127 \times 200 = 26,397&lt;/math&gt;. Analyze the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers with this method as a function of &lt;math&gt;n&lt;/math&gt; (assume constant base size). Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time.

[[2.43|Solution]]

===Logartihms===


:2.44. Prove the following identities on logarithms:
#Prove that &lt;math&gt;\log_a (xy) = \log_a x + \log_a y&lt;/math&gt;
#Prove that &lt;math&gt;\log_a x^y = y \log_a x&lt;/math&gt;
#Prove that &lt;math&gt;\log_a x = \frac{\log_b x}{\log_b a}&lt;/math&gt;
#Prove that &lt;math&gt;x^{\log_b y} = y^{\log_b x}&lt;/math&gt;


:[[2.45]]. Show that &lt;math&gt;\lceil \lg(n+1) \rceil = \lfloor \lg n \rfloor +1&lt;/math&gt;

[[2.45|Solution]]


:2.46. Prove that that the binary representation of &lt;math&gt;n \geq 1&lt;/math&gt; has &lt;math&gt;\lfloor \lg_2 n \rfloor&lt;/math&gt; + &lt;math&gt;1&lt;/math&gt; bits.


:[[2.47]]. In one of my research papers I give a comparison-based sorting algorithm that runs in &lt;math&gt;O( n \log (\sqrt n) )&lt;/math&gt;. Given the existence of an &lt;math&gt;\Omega(n \log n)&lt;/math&gt; lower bound for sorting, how can this be possible?
 

[[2.47|Solution]]

===Interview Problems===


:2.48. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; numbers. You must pick a subset &lt;math&gt;S'&lt;/math&gt; of &lt;math&gt;k&lt;/math&gt; numbers from &lt;math&gt;S&lt;/math&gt; such that the probability of each element of &lt;math&gt;S&lt;/math&gt; occurring in &lt;math&gt;S'&lt;/math&gt; is equal (i.e., each is selected with probability &lt;math&gt;k/n&lt;/math&gt;). You may make only one pass over the numbers. What if &lt;math&gt;n&lt;/math&gt; is unknown?


:[[2.49]]. We have 1,000 data items to store on 1,000 nodes. Each node can store copies of exactly three different items. Propose a replication scheme to minimize data loss as nodes fail. What is the expected number of data entries that get lost when three random nodes fail?

[[2.49|Solution]]


:2.50. Consider the following algorithm to find the minimum element in an array of numbers &lt;math&gt;A[0, \ldots, n]&lt;/math&gt;. One extra variable &lt;math&gt;tmp&lt;/math&gt; is allocated to hold the current minimum value. Start from A[0]; "tmp" is compared against &lt;math&gt;A[1]&lt;/math&gt;, 
&lt;math&gt;A[2]&lt;/math&gt;, &lt;math&gt;\ldots&lt;/math&gt;, &lt;math&gt;A[N]&lt;/math&gt; in order. When &lt;math&gt;A[i]&lt;tmp&lt;/math&gt;, &lt;math&gt;tmp = A[i]&lt;/math&gt;. What is the expected number of times that the assignment operation &lt;math&gt;tmp = A[i]&lt;/math&gt; is performed?


:[[2.51]]. You are given ten bags of gold coins. Nine bags contain coins that each weigh 10 grams. One bag contains all false coins that weigh 1 gram less. You must identify this bag in just one weighing. You have a digital balance that reports the weight of what is placed on it.

[[2.51|Solution]]


:2.52. You have eight balls all of the same size. Seven of them weigh the same, and one of them weighs slightly more. How can you find the ball that is heavier by using a balance and only two weightings?


:[[2.53]]. Suppose we start with &lt;math&gt;n&lt;/math&gt; companies that eventually merge into one big company. How many different ways are there for them to merge?

[[2.53|Solution]]


:2.54. Six pirates must divide $300 among themselves. The division is to proceed as follows. The senior pirate proposes a way to divide the money. Then the pirates vote. If the senior pirate gets at least half the votes he wins, and that division remains. If he doesn’t, he is killed and then the next senior-most pirate gets a chance to propose the division. Now tell what will happen and why (i.e. how many pirates survive and how the division is done)? All the pirates are intelligent and the first priority is to stay alive and the next priority is to get as much money as possible.


:[[2.55]]. Reconsider the pirate problem above, where we start with only one indivisible dollar. Who gets the dollar, and how many are killed?

[[2.55|Solution]]


Back to [[Chapter List]]</text>
      <sha1>husu2lilmi2lf7ly28n8fmr6jpdh0wl</sha1>
    </revision>
    <revision>
      <id>160</id>
      <parentid>133</parentid>
      <timestamp>2020-09-10T20:02:27Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Program Analysis */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="18071">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
       ''return''(r)


:[[2.5]]. Consider the following algorithm: (the print operation prints a single asterisk; the operation &lt;math&gt;x = 2x&lt;/math&gt; doubles the value of the variable &lt;math&gt;x&lt;/math&gt;).
    ''for'' &lt;math&gt; k = 1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt;
        &lt;math&gt;x = k&lt;/math&gt;
        ''while'' (&lt;math&gt;x &lt; n&lt;/math&gt;):
           ''print'' '*'
           &lt;math&gt;x = 2x&lt;/math&gt;
:Let &lt;math&gt;f(n)&lt;/math&gt; be the complexity of this algorithm (or equivalently the number of times * is printed). Proivde correct bounds for &lt;math&gt; O(f(n))&lt;/math&gt;, and &lt;math&gt;\Theta(f(n))&lt;/math&gt;, ideally converging on &lt;math&gt;\Theta(f(n))&lt;/math&gt;.

[[2.5|Solution]]


:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. True or False?
#Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.9|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]. For each of the following functions, which of the following asymptotic bounds hold for &lt;math&gt;f(n) = O(g(n)),\Theta(g(n)),\Omega(g(n))&lt;/math&gt;?
#&lt;math&gt;f(n) = 3n^2, g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = 2n^4 - 3n^2 + 7, g(n) = n^5&lt;/math&gt;
#&lt;math&gt;f(n) = log n, g(n) = log n + 1/n&lt;/math&gt;
#&lt;math&gt;f(n) = 2^{klog n}, g(n) = n^k&lt;/math&gt;
#&lt;math&gt;f(n) = 2^n, g(n) = 2^{2n}&lt;/math&gt;

[[2.11|Solution]]


:2.12. Prove that &lt;math&gt;n^3 - 3n^2-n+1 = \Theta(n^3)&lt;/math&gt;.


:2.13. Prove that &lt;math&gt;n^2 = O(2^n)&lt;/math&gt;.

[[2.13|Solution]]


:2.14. Prove or disprove: &lt;math&gt;\Theta(n^2) = \Theta(n^2+1)&lt;/math&gt;.


:[[2.15]]. Suppose you have algorithms with the five running times listed below. (Assume these are the exact running times.) How much slower do each of these inputs get when you (a) double the input size, or (b) increase the input size by one?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;

[[2.15|Solution]]


:2.16.  Suppose you have algorithms with the six running times listed below. (Assume these are the exact number of operations performed as a function of input size &lt;math&gt;n&lt;/math&gt;.)Suppose you have a computer that can perform &lt;math&gt;10^10&lt;/math&gt; operations per second. For each algorithm, what is the largest input size n that you can complete within an hour?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;  (f) &lt;math&gt;2^{2^n}&lt;/math&gt;


:[[2.17]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, give an appropriate positive constant &lt;math&gt;c&lt;/math&gt; such that &lt;math&gt;f(n) \leq c \cdot g(n)&lt;/math&gt; for all &lt;math&gt;n &gt; 1&lt;/math&gt;.
#&lt;math&gt;f(n)=n^2+n+1&lt;/math&gt;, &lt;math&gt;g(n)=2n^3&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n + n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^2&lt;/math&gt;
#&lt;math&gt;f(n)=n^2-n+1&lt;/math&gt;, &lt;math&gt;g(n)=n^2/2&lt;/math&gt;

[[2.17|Solution]]


:2.18. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n) = O(g_1(n)+g_2(n))&lt;/math&gt;.


:[[2.19]]. Prove that if &lt;math&gt;f_1(N)=\Omega(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=\Omega(g_2(n) &lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n)=\Omega(g_1(n)+g_2(n))&lt;/math&gt;.

[[2.19|Solution]]


:2.20. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n) \cdot f_2(n) = O(g_1(n) \cdot g_2(n))&lt;/math&gt;


:[[2.21]]. Prove for all &lt;math&gt;k \geq 1&lt;/math&gt; and all sets of constants &lt;math&gt;\{a_k, a_{k-1}, \ldots, a_1,a_0\} \in R&lt;/math&gt;, &lt;math&gt; a_k n^k + a_{k-1}n^{k-1}+....+a_1 n + a_0 = O(n^k)&lt;/math&gt;

[[2.21|Solution]]


:2.22. Show that for any real constants &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;, &lt;math&gt;b &gt; 0&lt;/math&gt;
&lt;center&gt;&lt;math&gt;(n + a)^b = \Omega (n^b)&lt;/math&gt;&lt;/center&gt;


:[[2.23]]. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{llll}
n &amp; 2^n &amp; n \lg n &amp; \ln n \\
n-n^3+7n^5 &amp; \lg n &amp; \sqrt n &amp; e^n \\
n^2+\lg n &amp; n^2 &amp; 2^{n-1} &amp;  \lg \lg n \\
n^3 &amp; (\lg n)^2 &amp; n! &amp; n^{1+\varepsilon} where 0&lt; \varepsilon &lt;1
\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.23|Solution]]


:2.24


:[[2.25]]

[[2.25|Solution]]


:2.26. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{lll}
\sqrt{n} &amp; n &amp; 2^n \\
n \log n &amp;  n - n^3 + 7n^5 &amp;  n^2 + \log n \\
n^2 &amp;  n^3 &amp;  \log n \\
n^{\frac{1}{3}} + \log n &amp; (\log n)^2 &amp;  n! \\
\ln n &amp; \frac{n}{\log n} &amp;  \log \log n \\
({1}/{3})^n &amp;  ({3}/{2})^n &amp;  6 \\
\end{array}&lt;/math&gt;
&lt;/center&gt;


:[[2.27]]. Find two functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt; that satisfy the following relationship. If no such &lt;math&gt;f&lt;/math&gt; and &lt;math&gt;g&lt;/math&gt; exist, write ''None.''
#&lt;math&gt;f(n)=o(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq \Theta(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n)=o(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;

[[2.27|Solution]]


:2.28. True or False?
#&lt;math&gt;2n^2+1=O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n= O(\log n)&lt;/math&gt;
#&lt;math&gt;\log n = O(\sqrt n)&lt;/math&gt;
#&lt;math&gt;n^2(1 + \sqrt n) = O(n^2 \log n)&lt;/math&gt;
#&lt;math&gt;3n^2 + \sqrt n = O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n \log n= O(n) &lt;/math&gt;
#&lt;math&gt;\log n=O(n^{-1/2})&lt;/math&gt;


:[[2.29]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, state whether &lt;math&gt;f(n)=O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;, or none of the above.
#&lt;math&gt;f(n)=n^2+3n+4&lt;/math&gt;, &lt;math&gt;g(n)=6n+7&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n&lt;/math&gt;, &lt;math&gt;g(n)=n^2-n&lt;/math&gt;
#&lt;math&gt;f(n)=2^n - n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^4+n^2&lt;/math&gt;

[[2.29|Solution]]. 


:2.30. For each of these questions, briefly explain your answer.
::(a) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
::(b) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
::(c) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
::(d) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
::(e) Is the function &lt;math&gt;f(n) = \Theta(n^2)&lt;/math&gt;, where &lt;math&gt;f(n) = 100 n^2&lt;/math&gt; for even &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;f(n) = 20 n^2 - n \log_2 n&lt;/math&gt; for odd &lt;math&gt;n&lt;/math&gt;?


:[[2.31]]. For each of the following, answer ''yes'', ''no'', or ''can't tell''. Explain your reasoning.
::(a) Is &lt;math&gt;3^n = O(2^n)&lt;/math&gt;?
::(b) Is &lt;math&gt;\log 3^n = O( \log 2^n )&lt;/math&gt;?
::(c) Is &lt;math&gt;3^n = \Omega(2^n)&lt;/math&gt;?
::(d) Is &lt;math&gt;\log 3^n = \Omega( \log 2^n )&lt;/math&gt;?

[[2.31|Solution]]


:2.32. For each of the following expressions &lt;math&gt;f(n)&lt;/math&gt; find a simple &lt;math&gt;g(n)&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n {1\over i}&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \lceil {1\over i}\rceil&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \log i&lt;/math&gt;.
#&lt;math&gt;f(n)=\log (n!)&lt;/math&gt;.


:[[2.33]]. Place the following functions into increasing asymptotic order.
::&lt;math&gt;f_1(n) = n^2\log_2n&lt;/math&gt;, &lt;math&gt;f_2(n) = n(\log_2n)^2&lt;/math&gt;, &lt;math&gt;f_3(n) = \sum_{i=0}^n 2^i&lt;/math&gt;, &lt;math&gt;f_4(n) = \log_2(\sum_{i=0}^n 2^i)&lt;/math&gt;.

[[2.33|Solution]]


:2.34. Which of the following are true?
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n-1})&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^n)&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n+1})&lt;/math&gt;.


:[[2.35]]. For each of the following functions &lt;math&gt;f&lt;/math&gt; find a simple function &lt;math&gt;g&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f_1(n)= (1000)2^n + 4^n&lt;/math&gt;.
#&lt;math&gt;f_2(n)= n + n\log n + \sqrt n&lt;/math&gt;.
#&lt;math&gt;f_3(n)= \log (n^{20}) + (\log n)^{10}&lt;/math&gt;.
#&lt;math&gt;f_4(n)= (0.99)^n + n^{100}.&lt;/math&gt;

[[2.35|Solution]]


:2.36. For each pair of expressions &lt;math&gt;(A,B)&lt;/math&gt; below, indicate whether &lt;math&gt;A&lt;/math&gt; is &lt;math&gt;O&lt;/math&gt;, &lt;math&gt;o&lt;/math&gt;, &lt;math&gt;\Omega&lt;/math&gt;, &lt;math&gt;\omega&lt;/math&gt;, or &lt;math&gt;\Theta&lt;/math&gt; of &lt;math&gt;B&lt;/math&gt;.  Note that zero, one or more of these relations may hold for a given pair; list all correct ones.
&lt;br&gt;&lt;center&gt;&lt;math&gt;
\begin{array}{lcc}
        &amp; A                     &amp; B \\
(a)     &amp; n^{100}               &amp; 2^n \\
(b)     &amp; (\lg n)^{12}         &amp; \sqrt{n} \\
(c)     &amp; \sqrt{n}              &amp; n^{\cos (\pi n/8)} \\
(d)     &amp; 10^n                  &amp; 100^n \\
(e)     &amp; n^{\lg n}            &amp; (\lg n)^n \\
(f)     &amp; \lg{(n!)}            &amp; n \lg n
\end{array}
&lt;/math&gt;&lt;/center&gt;

===Summations===


:[[2.37]]. Find an expression for the sum of the &lt;math&gt;i&lt;/math&gt;th row of the following triangle, and prove its correctness. Each entry is the sum of the three entries directly above it. All non existing entries are considered 0.
&lt;center&gt;
&lt;math&gt;\begin{array}{ccccccccc}
&amp;&amp;&amp;&amp;1&amp;&amp;&amp;&amp; \\
&amp;&amp;&amp;1&amp;1&amp;1&amp;&amp;&amp;\\
&amp;&amp;1&amp;2&amp;3&amp;2&amp;1&amp;&amp;\\
&amp;1&amp;3&amp;6&amp;7&amp;6&amp;3&amp;1&amp;\\
1&amp;4&amp;10&amp;16&amp;19&amp;16&amp;10&amp;4&amp;1\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.37|Solution]]


:2.38. Assume that Christmas has &lt;math&gt;n&lt;/math&gt; days. Exactly how many presents did my ''true love'' send me? (Do some research if you do not understand this question.)


:[[2.39]]

[[2.39|Solution]]


:2.40. Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n do
      for j=i to 2*i do
         output ''foobar''
&lt;/tt&gt;
:Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as a summation (actually two nested summations).
#Simplify the summation.  Show your work.


:[[2.41]].Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n/2 do
      for j=i to n-i do
         for k=1 to j do
            output ''foobar''
&lt;/tt&gt;
:Assume &lt;math&gt;n&lt;/math&gt; is even. Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as three nested summations.
#Simplify the summation.  Show your work.

[[2.41|Solution]]


:2.42. When you first learned to multiply numbers, you were told that &lt;math&gt;x \times y&lt;/math&gt; means adding &lt;math&gt;x&lt;/math&gt; a total of &lt;math&gt;y&lt;/math&gt; times, so &lt;math&gt;5 \times 4 = 5+5+5+5 = 20&lt;/math&gt;. What is the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers in base &lt;math&gt;b&lt;/math&gt; (people work in base 10, of course, while computers work in base 2) using the repeated addition method, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;. Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time. (Hint: how big can &lt;math&gt;y&lt;/math&gt; be as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;?)


:[[2.43]]. In grade school, you learned to multiply long numbers on a digit-by-digit basis, so that &lt;math&gt;127 \times 211 = 127 \times 1 + 127 \times 10 + 127 \times 200 = 26,397&lt;/math&gt;. Analyze the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers with this method as a function of &lt;math&gt;n&lt;/math&gt; (assume constant base size). Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time.

[[2.43|Solution]]

===Logartihms===


:2.44. Prove the following identities on logarithms:
#Prove that &lt;math&gt;\log_a (xy) = \log_a x + \log_a y&lt;/math&gt;
#Prove that &lt;math&gt;\log_a x^y = y \log_a x&lt;/math&gt;
#Prove that &lt;math&gt;\log_a x = \frac{\log_b x}{\log_b a}&lt;/math&gt;
#Prove that &lt;math&gt;x^{\log_b y} = y^{\log_b x}&lt;/math&gt;


:[[2.45]]. Show that &lt;math&gt;\lceil \lg(n+1) \rceil = \lfloor \lg n \rfloor +1&lt;/math&gt;

[[2.45|Solution]]


:2.46. Prove that that the binary representation of &lt;math&gt;n \geq 1&lt;/math&gt; has &lt;math&gt;\lfloor \lg_2 n \rfloor&lt;/math&gt; + &lt;math&gt;1&lt;/math&gt; bits.


:[[2.47]]. In one of my research papers I give a comparison-based sorting algorithm that runs in &lt;math&gt;O( n \log (\sqrt n) )&lt;/math&gt;. Given the existence of an &lt;math&gt;\Omega(n \log n)&lt;/math&gt; lower bound for sorting, how can this be possible?
 

[[2.47|Solution]]

===Interview Problems===


:2.48. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; numbers. You must pick a subset &lt;math&gt;S'&lt;/math&gt; of &lt;math&gt;k&lt;/math&gt; numbers from &lt;math&gt;S&lt;/math&gt; such that the probability of each element of &lt;math&gt;S&lt;/math&gt; occurring in &lt;math&gt;S'&lt;/math&gt; is equal (i.e., each is selected with probability &lt;math&gt;k/n&lt;/math&gt;). You may make only one pass over the numbers. What if &lt;math&gt;n&lt;/math&gt; is unknown?


:[[2.49]]. We have 1,000 data items to store on 1,000 nodes. Each node can store copies of exactly three different items. Propose a replication scheme to minimize data loss as nodes fail. What is the expected number of data entries that get lost when three random nodes fail?

[[2.49|Solution]]


:2.50. Consider the following algorithm to find the minimum element in an array of numbers &lt;math&gt;A[0, \ldots, n]&lt;/math&gt;. One extra variable &lt;math&gt;tmp&lt;/math&gt; is allocated to hold the current minimum value. Start from A[0]; "tmp" is compared against &lt;math&gt;A[1]&lt;/math&gt;, 
&lt;math&gt;A[2]&lt;/math&gt;, &lt;math&gt;\ldots&lt;/math&gt;, &lt;math&gt;A[N]&lt;/math&gt; in order. When &lt;math&gt;A[i]&lt;tmp&lt;/math&gt;, &lt;math&gt;tmp = A[i]&lt;/math&gt;. What is the expected number of times that the assignment operation &lt;math&gt;tmp = A[i]&lt;/math&gt; is performed?


:[[2.51]]. You are given ten bags of gold coins. Nine bags contain coins that each weigh 10 grams. One bag contains all false coins that weigh 1 gram less. You must identify this bag in just one weighing. You have a digital balance that reports the weight of what is placed on it.

[[2.51|Solution]]


:2.52. You have eight balls all of the same size. Seven of them weigh the same, and one of them weighs slightly more. How can you find the ball that is heavier by using a balance and only two weightings?


:[[2.53]]. Suppose we start with &lt;math&gt;n&lt;/math&gt; companies that eventually merge into one big company. How many different ways are there for them to merge?

[[2.53|Solution]]


:2.54. Six pirates must divide $300 among themselves. The division is to proceed as follows. The senior pirate proposes a way to divide the money. Then the pirates vote. If the senior pirate gets at least half the votes he wins, and that division remains. If he doesn’t, he is killed and then the next senior-most pirate gets a chance to propose the division. Now tell what will happen and why (i.e. how many pirates survive and how the division is done)? All the pirates are intelligent and the first priority is to stay alive and the next priority is to get as much money as possible.


:[[2.55]]. Reconsider the pirate problem above, where we start with only one indivisible dollar. Who gets the dollar, and how many are killed?

[[2.55|Solution]]


Back to [[Chapter List]]</text>
      <sha1>3q050b2wvjup8rwbkcl6fqllv34r2ic</sha1>
    </revision>
    <revision>
      <id>161</id>
      <parentid>160</parentid>
      <timestamp>2020-09-10T20:14:52Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Big Oh */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="18552">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
       ''return''(r)


:[[2.5]]. Consider the following algorithm: (the print operation prints a single asterisk; the operation &lt;math&gt;x = 2x&lt;/math&gt; doubles the value of the variable &lt;math&gt;x&lt;/math&gt;).
    ''for'' &lt;math&gt; k = 1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt;
        &lt;math&gt;x = k&lt;/math&gt;
        ''while'' (&lt;math&gt;x &lt; n&lt;/math&gt;):
           ''print'' '*'
           &lt;math&gt;x = 2x&lt;/math&gt;
:Let &lt;math&gt;f(n)&lt;/math&gt; be the complexity of this algorithm (or equivalently the number of times * is printed). Proivde correct bounds for &lt;math&gt; O(f(n))&lt;/math&gt;, and &lt;math&gt;\Theta(f(n))&lt;/math&gt;, ideally converging on &lt;math&gt;\Theta(f(n))&lt;/math&gt;.

[[2.5|Solution]]


:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. True or False?
#Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.9|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]. For each of the following functions, which of the following asymptotic bounds hold for &lt;math&gt;f(n) = O(g(n)),\Theta(g(n)),\Omega(g(n))&lt;/math&gt;?
#&lt;math&gt;f(n) = 3n^2, g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = 2n^4 - 3n^2 + 7, g(n) = n^5&lt;/math&gt;
#&lt;math&gt;f(n) = log n, g(n) = log n + 1/n&lt;/math&gt;
#&lt;math&gt;f(n) = 2^{klog n}, g(n) = n^k&lt;/math&gt;
#&lt;math&gt;f(n) = 2^n, g(n) = 2^{2n}&lt;/math&gt;

[[2.11|Solution]]


:2.12. Prove that &lt;math&gt;n^3 - 3n^2-n+1 = \Theta(n^3)&lt;/math&gt;.


:2.13. Prove that &lt;math&gt;n^2 = O(2^n)&lt;/math&gt;.

[[2.13|Solution]]


:2.14. Prove or disprove: &lt;math&gt;\Theta(n^2) = \Theta(n^2+1)&lt;/math&gt;.


:[[2.15]]. Suppose you have algorithms with the five running times listed below. (Assume these are the exact running times.) How much slower do each of these inputs get when you (a) double the input size, or (b) increase the input size by one?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;

[[2.15|Solution]]


:2.16.  Suppose you have algorithms with the six running times listed below. (Assume these are the exact number of operations performed as a function of input size &lt;math&gt;n&lt;/math&gt;.)Suppose you have a computer that can perform &lt;math&gt;10^10&lt;/math&gt; operations per second. For each algorithm, what is the largest input size n that you can complete within an hour?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;  (f) &lt;math&gt;2^{2^n}&lt;/math&gt;


:[[2.17]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, give an appropriate positive constant &lt;math&gt;c&lt;/math&gt; such that &lt;math&gt;f(n) \leq c \cdot g(n)&lt;/math&gt; for all &lt;math&gt;n &gt; 1&lt;/math&gt;.
#&lt;math&gt;f(n)=n^2+n+1&lt;/math&gt;, &lt;math&gt;g(n)=2n^3&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n + n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^2&lt;/math&gt;
#&lt;math&gt;f(n)=n^2-n+1&lt;/math&gt;, &lt;math&gt;g(n)=n^2/2&lt;/math&gt;

[[2.17|Solution]]


:2.18. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n) = O(g_1(n)+g_2(n))&lt;/math&gt;.


:[[2.19]]. Prove that if &lt;math&gt;f_1(N)=\Omega(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=\Omega(g_2(n) &lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n)=\Omega(g_1(n)+g_2(n))&lt;/math&gt;.

[[2.19|Solution]]


:2.20. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n) \cdot f_2(n) = O(g_1(n) \cdot g_2(n))&lt;/math&gt;


:[[2.21]]. Prove for all &lt;math&gt;k \geq 1&lt;/math&gt; and all sets of constants &lt;math&gt;\{a_k, a_{k-1}, \ldots, a_1,a_0\} \in R&lt;/math&gt;, &lt;math&gt; a_k n^k + a_{k-1}n^{k-1}+....+a_1 n + a_0 = O(n^k)&lt;/math&gt;

[[2.21|Solution]]


:2.22. Show that for any real constants &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;, &lt;math&gt;b &gt; 0&lt;/math&gt;
&lt;center&gt;&lt;math&gt;(n + a)^b = \Omega (n^b)&lt;/math&gt;&lt;/center&gt;


:[[2.23]]. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{llll}
n &amp; 2^n &amp; n \lg n &amp; \ln n \\
n-n^3+7n^5 &amp; \lg n &amp; \sqrt n &amp; e^n \\
n^2+\lg n &amp; n^2 &amp; 2^{n-1} &amp;  \lg \lg n \\
n^3 &amp; (\lg n)^2 &amp; n! &amp; n^{1+\varepsilon} where 0&lt; \varepsilon &lt;1
\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.23|Solution]]


:2.24. List the functions below from lowest to highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}
n^{\pi} &amp; {\pi}^n &amp; \binom{n}{5} &amp; \sqrt{2\sqrt{n}} \\
\binom{n}{n-4} &amp; 2^{log^4n} &amp; n^{5(logn)^2} $ n^4\binom{n}{n-4}
\\
\end{array}&lt;/math&gt;
&lt;/center&gt;


:[[2.25]]. List the functions below from lowest to highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{llll}
FILL IN
\end{array}&lt;/math&gt;
&lt;/center&gt;


[[2.25|Solution]]


:2.26. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{lll}
\sqrt{n} &amp; n &amp; 2^n \\
n \log n &amp;  n - n^3 + 7n^5 &amp;  n^2 + \log n \\
n^2 &amp;  n^3 &amp;  \log n \\
n^{\frac{1}{3}} + \log n &amp; (\log n)^2 &amp;  n! \\
\ln n &amp; \frac{n}{\log n} &amp;  \log \log n \\
({1}/{3})^n &amp;  ({3}/{2})^n &amp;  6 \\
\end{array}&lt;/math&gt;
&lt;/center&gt;


:[[2.27]]. Find two functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt; that satisfy the following relationship. If no such &lt;math&gt;f&lt;/math&gt; and &lt;math&gt;g&lt;/math&gt; exist, write ''None.''
#&lt;math&gt;f(n)=o(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq \Theta(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n)=o(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;

[[2.27|Solution]]


:2.28. True or False?
#&lt;math&gt;2n^2+1=O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n= O(\log n)&lt;/math&gt;
#&lt;math&gt;\log n = O(\sqrt n)&lt;/math&gt;
#&lt;math&gt;n^2(1 + \sqrt n) = O(n^2 \log n)&lt;/math&gt;
#&lt;math&gt;3n^2 + \sqrt n = O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n \log n= O(n) &lt;/math&gt;
#&lt;math&gt;\log n=O(n^{-1/2})&lt;/math&gt;


:[[2.29]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, state whether &lt;math&gt;f(n)=O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;, or none of the above.
#&lt;math&gt;f(n)=n^2+3n+4&lt;/math&gt;, &lt;math&gt;g(n)=6n+7&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n&lt;/math&gt;, &lt;math&gt;g(n)=n^2-n&lt;/math&gt;
#&lt;math&gt;f(n)=2^n - n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^4+n^2&lt;/math&gt;

[[2.29|Solution]]. 


:2.30. For each of these questions, briefly explain your answer.
::(a) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
::(b) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
::(c) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
::(d) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
::(e) Is the function &lt;math&gt;f(n) = \Theta(n^2)&lt;/math&gt;, where &lt;math&gt;f(n) = 100 n^2&lt;/math&gt; for even &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;f(n) = 20 n^2 - n \log_2 n&lt;/math&gt; for odd &lt;math&gt;n&lt;/math&gt;?


:[[2.31]]. For each of the following, answer ''yes'', ''no'', or ''can't tell''. Explain your reasoning.
::(a) Is &lt;math&gt;3^n = O(2^n)&lt;/math&gt;?
::(b) Is &lt;math&gt;\log 3^n = O( \log 2^n )&lt;/math&gt;?
::(c) Is &lt;math&gt;3^n = \Omega(2^n)&lt;/math&gt;?
::(d) Is &lt;math&gt;\log 3^n = \Omega( \log 2^n )&lt;/math&gt;?

[[2.31|Solution]]


:2.32. For each of the following expressions &lt;math&gt;f(n)&lt;/math&gt; find a simple &lt;math&gt;g(n)&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n {1\over i}&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \lceil {1\over i}\rceil&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \log i&lt;/math&gt;.
#&lt;math&gt;f(n)=\log (n!)&lt;/math&gt;.


:[[2.33]]. Place the following functions into increasing asymptotic order.
::&lt;math&gt;f_1(n) = n^2\log_2n&lt;/math&gt;, &lt;math&gt;f_2(n) = n(\log_2n)^2&lt;/math&gt;, &lt;math&gt;f_3(n) = \sum_{i=0}^n 2^i&lt;/math&gt;, &lt;math&gt;f_4(n) = \log_2(\sum_{i=0}^n 2^i)&lt;/math&gt;.

[[2.33|Solution]]


:2.34. Which of the following are true?
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n-1})&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^n)&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n+1})&lt;/math&gt;.


:[[2.35]]. For each of the following functions &lt;math&gt;f&lt;/math&gt; find a simple function &lt;math&gt;g&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f_1(n)= (1000)2^n + 4^n&lt;/math&gt;.
#&lt;math&gt;f_2(n)= n + n\log n + \sqrt n&lt;/math&gt;.
#&lt;math&gt;f_3(n)= \log (n^{20}) + (\log n)^{10}&lt;/math&gt;.
#&lt;math&gt;f_4(n)= (0.99)^n + n^{100}.&lt;/math&gt;

[[2.35|Solution]]


:2.36. For each pair of expressions &lt;math&gt;(A,B)&lt;/math&gt; below, indicate whether &lt;math&gt;A&lt;/math&gt; is &lt;math&gt;O&lt;/math&gt;, &lt;math&gt;o&lt;/math&gt;, &lt;math&gt;\Omega&lt;/math&gt;, &lt;math&gt;\omega&lt;/math&gt;, or &lt;math&gt;\Theta&lt;/math&gt; of &lt;math&gt;B&lt;/math&gt;.  Note that zero, one or more of these relations may hold for a given pair; list all correct ones.
&lt;br&gt;&lt;center&gt;&lt;math&gt;
\begin{array}{lcc}
        &amp; A                     &amp; B \\
(a)     &amp; n^{100}               &amp; 2^n \\
(b)     &amp; (\lg n)^{12}         &amp; \sqrt{n} \\
(c)     &amp; \sqrt{n}              &amp; n^{\cos (\pi n/8)} \\
(d)     &amp; 10^n                  &amp; 100^n \\
(e)     &amp; n^{\lg n}            &amp; (\lg n)^n \\
(f)     &amp; \lg{(n!)}            &amp; n \lg n
\end{array}
&lt;/math&gt;&lt;/center&gt;

===Summations===


:[[2.37]]. Find an expression for the sum of the &lt;math&gt;i&lt;/math&gt;th row of the following triangle, and prove its correctness. Each entry is the sum of the three entries directly above it. All non existing entries are considered 0.
&lt;center&gt;
&lt;math&gt;\begin{array}{ccccccccc}
&amp;&amp;&amp;&amp;1&amp;&amp;&amp;&amp; \\
&amp;&amp;&amp;1&amp;1&amp;1&amp;&amp;&amp;\\
&amp;&amp;1&amp;2&amp;3&amp;2&amp;1&amp;&amp;\\
&amp;1&amp;3&amp;6&amp;7&amp;6&amp;3&amp;1&amp;\\
1&amp;4&amp;10&amp;16&amp;19&amp;16&amp;10&amp;4&amp;1\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.37|Solution]]


:2.38. Assume that Christmas has &lt;math&gt;n&lt;/math&gt; days. Exactly how many presents did my ''true love'' send me? (Do some research if you do not understand this question.)


:[[2.39]]

[[2.39|Solution]]


:2.40. Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n do
      for j=i to 2*i do
         output ''foobar''
&lt;/tt&gt;
:Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as a summation (actually two nested summations).
#Simplify the summation.  Show your work.


:[[2.41]].Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n/2 do
      for j=i to n-i do
         for k=1 to j do
            output ''foobar''
&lt;/tt&gt;
:Assume &lt;math&gt;n&lt;/math&gt; is even. Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as three nested summations.
#Simplify the summation.  Show your work.

[[2.41|Solution]]


:2.42. When you first learned to multiply numbers, you were told that &lt;math&gt;x \times y&lt;/math&gt; means adding &lt;math&gt;x&lt;/math&gt; a total of &lt;math&gt;y&lt;/math&gt; times, so &lt;math&gt;5 \times 4 = 5+5+5+5 = 20&lt;/math&gt;. What is the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers in base &lt;math&gt;b&lt;/math&gt; (people work in base 10, of course, while computers work in base 2) using the repeated addition method, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;. Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time. (Hint: how big can &lt;math&gt;y&lt;/math&gt; be as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;?)


:[[2.43]]. In grade school, you learned to multiply long numbers on a digit-by-digit basis, so that &lt;math&gt;127 \times 211 = 127 \times 1 + 127 \times 10 + 127 \times 200 = 26,397&lt;/math&gt;. Analyze the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers with this method as a function of &lt;math&gt;n&lt;/math&gt; (assume constant base size). Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time.

[[2.43|Solution]]

===Logartihms===


:2.44. Prove the following identities on logarithms:
#Prove that &lt;math&gt;\log_a (xy) = \log_a x + \log_a y&lt;/math&gt;
#Prove that &lt;math&gt;\log_a x^y = y \log_a x&lt;/math&gt;
#Prove that &lt;math&gt;\log_a x = \frac{\log_b x}{\log_b a}&lt;/math&gt;
#Prove that &lt;math&gt;x^{\log_b y} = y^{\log_b x}&lt;/math&gt;


:[[2.45]]. Show that &lt;math&gt;\lceil \lg(n+1) \rceil = \lfloor \lg n \rfloor +1&lt;/math&gt;

[[2.45|Solution]]


:2.46. Prove that that the binary representation of &lt;math&gt;n \geq 1&lt;/math&gt; has &lt;math&gt;\lfloor \lg_2 n \rfloor&lt;/math&gt; + &lt;math&gt;1&lt;/math&gt; bits.


:[[2.47]]. In one of my research papers I give a comparison-based sorting algorithm that runs in &lt;math&gt;O( n \log (\sqrt n) )&lt;/math&gt;. Given the existence of an &lt;math&gt;\Omega(n \log n)&lt;/math&gt; lower bound for sorting, how can this be possible?
 

[[2.47|Solution]]

===Interview Problems===


:2.48. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; numbers. You must pick a subset &lt;math&gt;S'&lt;/math&gt; of &lt;math&gt;k&lt;/math&gt; numbers from &lt;math&gt;S&lt;/math&gt; such that the probability of each element of &lt;math&gt;S&lt;/math&gt; occurring in &lt;math&gt;S'&lt;/math&gt; is equal (i.e., each is selected with probability &lt;math&gt;k/n&lt;/math&gt;). You may make only one pass over the numbers. What if &lt;math&gt;n&lt;/math&gt; is unknown?


:[[2.49]]. We have 1,000 data items to store on 1,000 nodes. Each node can store copies of exactly three different items. Propose a replication scheme to minimize data loss as nodes fail. What is the expected number of data entries that get lost when three random nodes fail?

[[2.49|Solution]]


:2.50. Consider the following algorithm to find the minimum element in an array of numbers &lt;math&gt;A[0, \ldots, n]&lt;/math&gt;. One extra variable &lt;math&gt;tmp&lt;/math&gt; is allocated to hold the current minimum value. Start from A[0]; "tmp" is compared against &lt;math&gt;A[1]&lt;/math&gt;, 
&lt;math&gt;A[2]&lt;/math&gt;, &lt;math&gt;\ldots&lt;/math&gt;, &lt;math&gt;A[N]&lt;/math&gt; in order. When &lt;math&gt;A[i]&lt;tmp&lt;/math&gt;, &lt;math&gt;tmp = A[i]&lt;/math&gt;. What is the expected number of times that the assignment operation &lt;math&gt;tmp = A[i]&lt;/math&gt; is performed?


:[[2.51]]. You are given ten bags of gold coins. Nine bags contain coins that each weigh 10 grams. One bag contains all false coins that weigh 1 gram less. You must identify this bag in just one weighing. You have a digital balance that reports the weight of what is placed on it.

[[2.51|Solution]]


:2.52. You have eight balls all of the same size. Seven of them weigh the same, and one of them weighs slightly more. How can you find the ball that is heavier by using a balance and only two weightings?


:[[2.53]]. Suppose we start with &lt;math&gt;n&lt;/math&gt; companies that eventually merge into one big company. How many different ways are there for them to merge?

[[2.53|Solution]]


:2.54. Six pirates must divide $300 among themselves. The division is to proceed as follows. The senior pirate proposes a way to divide the money. Then the pirates vote. If the senior pirate gets at least half the votes he wins, and that division remains. If he doesn’t, he is killed and then the next senior-most pirate gets a chance to propose the division. Now tell what will happen and why (i.e. how many pirates survive and how the division is done)? All the pirates are intelligent and the first priority is to stay alive and the next priority is to get as much money as possible.


:[[2.55]]. Reconsider the pirate problem above, where we start with only one indivisible dollar. Who gets the dollar, and how many are killed?

[[2.55|Solution]]


Back to [[Chapter List]]</text>
      <sha1>56q9qdy5eo6qs3bqwwx3zuyf4i201de</sha1>
    </revision>
    <revision>
      <id>265</id>
      <parentid>161</parentid>
      <timestamp>2020-09-19T18:20:30Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Big Oh */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="18662">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
       ''return''(r)


:[[2.5]]. Consider the following algorithm: (the print operation prints a single asterisk; the operation &lt;math&gt;x = 2x&lt;/math&gt; doubles the value of the variable &lt;math&gt;x&lt;/math&gt;).
    ''for'' &lt;math&gt; k = 1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt;
        &lt;math&gt;x = k&lt;/math&gt;
        ''while'' (&lt;math&gt;x &lt; n&lt;/math&gt;):
           ''print'' '*'
           &lt;math&gt;x = 2x&lt;/math&gt;
:Let &lt;math&gt;f(n)&lt;/math&gt; be the complexity of this algorithm (or equivalently the number of times * is printed). Proivde correct bounds for &lt;math&gt; O(f(n))&lt;/math&gt;, and &lt;math&gt;\Theta(f(n))&lt;/math&gt;, ideally converging on &lt;math&gt;\Theta(f(n))&lt;/math&gt;.

[[2.5|Solution]]


:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. True or False?
#Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.9|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]. For each of the following functions, which of the following asymptotic bounds hold for &lt;math&gt;f(n) = O(g(n)),\Theta(g(n)),\Omega(g(n))&lt;/math&gt;?
#&lt;math&gt;f(n) = 3n^2, g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = 2n^4 - 3n^2 + 7, g(n) = n^5&lt;/math&gt;
#&lt;math&gt;f(n) = log n, g(n) = log n + 1/n&lt;/math&gt;
#&lt;math&gt;f(n) = 2^{klog n}, g(n) = n^k&lt;/math&gt;
#&lt;math&gt;f(n) = 2^n, g(n) = 2^{2n}&lt;/math&gt;

[[2.11|Solution]]


:2.12. Prove that &lt;math&gt;n^3 - 3n^2-n+1 = \Theta(n^3)&lt;/math&gt;.


:2.13. Prove that &lt;math&gt;n^2 = O(2^n)&lt;/math&gt;.

[[2.13|Solution]]


:2.14. Prove or disprove: &lt;math&gt;\Theta(n^2) = \Theta(n^2+1)&lt;/math&gt;.


:[[2.15]]. Suppose you have algorithms with the five running times listed below. (Assume these are the exact running times.) How much slower do each of these inputs get when you (a) double the input size, or (b) increase the input size by one?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;

[[2.15|Solution]]


:2.16.  Suppose you have algorithms with the six running times listed below. (Assume these are the exact number of operations performed as a function of input size &lt;math&gt;n&lt;/math&gt;.)Suppose you have a computer that can perform &lt;math&gt;10^10&lt;/math&gt; operations per second. For each algorithm, what is the largest input size n that you can complete within an hour?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;  (f) &lt;math&gt;2^{2^n}&lt;/math&gt;


:[[2.17]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, give an appropriate positive constant &lt;math&gt;c&lt;/math&gt; such that &lt;math&gt;f(n) \leq c \cdot g(n)&lt;/math&gt; for all &lt;math&gt;n &gt; 1&lt;/math&gt;.
#&lt;math&gt;f(n)=n^2+n+1&lt;/math&gt;, &lt;math&gt;g(n)=2n^3&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n + n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^2&lt;/math&gt;
#&lt;math&gt;f(n)=n^2-n+1&lt;/math&gt;, &lt;math&gt;g(n)=n^2/2&lt;/math&gt;

[[2.17|Solution]]


:2.18. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n) = O(g_1(n)+g_2(n))&lt;/math&gt;.


:[[2.19]]. Prove that if &lt;math&gt;f_1(N)=\Omega(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=\Omega(g_2(n) &lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n)=\Omega(g_1(n)+g_2(n))&lt;/math&gt;.

[[2.19|Solution]]


:2.20. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n) \cdot f_2(n) = O(g_1(n) \cdot g_2(n))&lt;/math&gt;


:[[2.21]]. Prove for all &lt;math&gt;k \geq 1&lt;/math&gt; and all sets of constants &lt;math&gt;\{a_k, a_{k-1}, \ldots, a_1,a_0\} \in R&lt;/math&gt;, &lt;math&gt; a_k n^k + a_{k-1}n^{k-1}+....+a_1 n + a_0 = O(n^k)&lt;/math&gt;

[[2.21|Solution]]


:2.22. Show that for any real constants &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;, &lt;math&gt;b &gt; 0&lt;/math&gt;
&lt;center&gt;&lt;math&gt;(n + a)^b = \Omega (n^b)&lt;/math&gt;&lt;/center&gt;


:[[2.23]]. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{llll}
n &amp; 2^n &amp; n \lg n &amp; \ln n \\
n-n^3+7n^5 &amp; \lg n &amp; \sqrt n &amp; e^n \\
n^2+\lg n &amp; n^2 &amp; 2^{n-1} &amp;  \lg \lg n \\
n^3 &amp; (\lg n)^2 &amp; n! &amp; n^{1+\varepsilon} where 0&lt; \varepsilon &lt;1
\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.23|Solution]]


:2.24. List the functions below from lowest to highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{llll}
n^{\pi} &amp; \pi^n &amp; \binom{n}{5} &amp; \sqrt{2\sqrt{n}} \\
\binom{n}{n-4} &amp; 2^{log^4n} &amp; n^{5(logn)^2} &amp; n^4\binom{n}{n-4}
\\
\end{array}&lt;/math&gt;
&lt;/center&gt;


:[[2.25]]. List the functions below from lowest to highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{llll}
\sum_{i=1}^n i^i &amp; n^n &amp; (log n)^{log n} &amp; 2^{(log n^2)}\\
n! &amp; 2^{log^4n} &amp; n^{(log n)^2} &amp; n^4 \binom{n}{n-4}\\
\end{array}&lt;/math&gt;
&lt;/center&gt;


[[2.25|Solution]]


:2.26. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{lll}
\sqrt{n} &amp; n &amp; 2^n \\
n \log n &amp;  n - n^3 + 7n^5 &amp;  n^2 + \log n \\
n^2 &amp;  n^3 &amp;  \log n \\
n^{\frac{1}{3}} + \log n &amp; (\log n)^2 &amp;  n! \\
\ln n &amp; \frac{n}{\log n} &amp;  \log \log n \\
({1}/{3})^n &amp;  ({3}/{2})^n &amp;  6 \\
\end{array}&lt;/math&gt;
&lt;/center&gt;


:[[2.27]]. Find two functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt; that satisfy the following relationship. If no such &lt;math&gt;f&lt;/math&gt; and &lt;math&gt;g&lt;/math&gt; exist, write ''None.''
#&lt;math&gt;f(n)=o(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq \Theta(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n)=o(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;

[[2.27|Solution]]


:2.28. True or False?
#&lt;math&gt;2n^2+1=O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n= O(\log n)&lt;/math&gt;
#&lt;math&gt;\log n = O(\sqrt n)&lt;/math&gt;
#&lt;math&gt;n^2(1 + \sqrt n) = O(n^2 \log n)&lt;/math&gt;
#&lt;math&gt;3n^2 + \sqrt n = O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n \log n= O(n) &lt;/math&gt;
#&lt;math&gt;\log n=O(n^{-1/2})&lt;/math&gt;


:[[2.29]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, state whether &lt;math&gt;f(n)=O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;, or none of the above.
#&lt;math&gt;f(n)=n^2+3n+4&lt;/math&gt;, &lt;math&gt;g(n)=6n+7&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n&lt;/math&gt;, &lt;math&gt;g(n)=n^2-n&lt;/math&gt;
#&lt;math&gt;f(n)=2^n - n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^4+n^2&lt;/math&gt;

[[2.29|Solution]]. 


:2.30. For each of these questions, briefly explain your answer.
::(a) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
::(b) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
::(c) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
::(d) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
::(e) Is the function &lt;math&gt;f(n) = \Theta(n^2)&lt;/math&gt;, where &lt;math&gt;f(n) = 100 n^2&lt;/math&gt; for even &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;f(n) = 20 n^2 - n \log_2 n&lt;/math&gt; for odd &lt;math&gt;n&lt;/math&gt;?


:[[2.31]]. For each of the following, answer ''yes'', ''no'', or ''can't tell''. Explain your reasoning.
::(a) Is &lt;math&gt;3^n = O(2^n)&lt;/math&gt;?
::(b) Is &lt;math&gt;\log 3^n = O( \log 2^n )&lt;/math&gt;?
::(c) Is &lt;math&gt;3^n = \Omega(2^n)&lt;/math&gt;?
::(d) Is &lt;math&gt;\log 3^n = \Omega( \log 2^n )&lt;/math&gt;?

[[2.31|Solution]]


:2.32. For each of the following expressions &lt;math&gt;f(n)&lt;/math&gt; find a simple &lt;math&gt;g(n)&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n {1\over i}&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \lceil {1\over i}\rceil&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \log i&lt;/math&gt;.
#&lt;math&gt;f(n)=\log (n!)&lt;/math&gt;.


:[[2.33]]. Place the following functions into increasing asymptotic order.
::&lt;math&gt;f_1(n) = n^2\log_2n&lt;/math&gt;, &lt;math&gt;f_2(n) = n(\log_2n)^2&lt;/math&gt;, &lt;math&gt;f_3(n) = \sum_{i=0}^n 2^i&lt;/math&gt;, &lt;math&gt;f_4(n) = \log_2(\sum_{i=0}^n 2^i)&lt;/math&gt;.

[[2.33|Solution]]


:2.34. Which of the following are true?
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n-1})&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^n)&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n+1})&lt;/math&gt;.


:[[2.35]]. For each of the following functions &lt;math&gt;f&lt;/math&gt; find a simple function &lt;math&gt;g&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f_1(n)= (1000)2^n + 4^n&lt;/math&gt;.
#&lt;math&gt;f_2(n)= n + n\log n + \sqrt n&lt;/math&gt;.
#&lt;math&gt;f_3(n)= \log (n^{20}) + (\log n)^{10}&lt;/math&gt;.
#&lt;math&gt;f_4(n)= (0.99)^n + n^{100}.&lt;/math&gt;

[[2.35|Solution]]


:2.36. For each pair of expressions &lt;math&gt;(A,B)&lt;/math&gt; below, indicate whether &lt;math&gt;A&lt;/math&gt; is &lt;math&gt;O&lt;/math&gt;, &lt;math&gt;o&lt;/math&gt;, &lt;math&gt;\Omega&lt;/math&gt;, &lt;math&gt;\omega&lt;/math&gt;, or &lt;math&gt;\Theta&lt;/math&gt; of &lt;math&gt;B&lt;/math&gt;.  Note that zero, one or more of these relations may hold for a given pair; list all correct ones.
&lt;br&gt;&lt;center&gt;&lt;math&gt;
\begin{array}{lcc}
        &amp; A                     &amp; B \\
(a)     &amp; n^{100}               &amp; 2^n \\
(b)     &amp; (\lg n)^{12}         &amp; \sqrt{n} \\
(c)     &amp; \sqrt{n}              &amp; n^{\cos (\pi n/8)} \\
(d)     &amp; 10^n                  &amp; 100^n \\
(e)     &amp; n^{\lg n}            &amp; (\lg n)^n \\
(f)     &amp; \lg{(n!)}            &amp; n \lg n
\end{array}
&lt;/math&gt;&lt;/center&gt;

===Summations===


:[[2.37]]. Find an expression for the sum of the &lt;math&gt;i&lt;/math&gt;th row of the following triangle, and prove its correctness. Each entry is the sum of the three entries directly above it. All non existing entries are considered 0.
&lt;center&gt;
&lt;math&gt;\begin{array}{ccccccccc}
&amp;&amp;&amp;&amp;1&amp;&amp;&amp;&amp; \\
&amp;&amp;&amp;1&amp;1&amp;1&amp;&amp;&amp;\\
&amp;&amp;1&amp;2&amp;3&amp;2&amp;1&amp;&amp;\\
&amp;1&amp;3&amp;6&amp;7&amp;6&amp;3&amp;1&amp;\\
1&amp;4&amp;10&amp;16&amp;19&amp;16&amp;10&amp;4&amp;1\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.37|Solution]]


:2.38. Assume that Christmas has &lt;math&gt;n&lt;/math&gt; days. Exactly how many presents did my ''true love'' send me? (Do some research if you do not understand this question.)


:[[2.39]]

[[2.39|Solution]]


:2.40. Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n do
      for j=i to 2*i do
         output ''foobar''
&lt;/tt&gt;
:Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as a summation (actually two nested summations).
#Simplify the summation.  Show your work.


:[[2.41]].Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n/2 do
      for j=i to n-i do
         for k=1 to j do
            output ''foobar''
&lt;/tt&gt;
:Assume &lt;math&gt;n&lt;/math&gt; is even. Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as three nested summations.
#Simplify the summation.  Show your work.

[[2.41|Solution]]


:2.42. When you first learned to multiply numbers, you were told that &lt;math&gt;x \times y&lt;/math&gt; means adding &lt;math&gt;x&lt;/math&gt; a total of &lt;math&gt;y&lt;/math&gt; times, so &lt;math&gt;5 \times 4 = 5+5+5+5 = 20&lt;/math&gt;. What is the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers in base &lt;math&gt;b&lt;/math&gt; (people work in base 10, of course, while computers work in base 2) using the repeated addition method, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;. Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time. (Hint: how big can &lt;math&gt;y&lt;/math&gt; be as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;?)


:[[2.43]]. In grade school, you learned to multiply long numbers on a digit-by-digit basis, so that &lt;math&gt;127 \times 211 = 127 \times 1 + 127 \times 10 + 127 \times 200 = 26,397&lt;/math&gt;. Analyze the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers with this method as a function of &lt;math&gt;n&lt;/math&gt; (assume constant base size). Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time.

[[2.43|Solution]]

===Logartihms===


:2.44. Prove the following identities on logarithms:
#Prove that &lt;math&gt;\log_a (xy) = \log_a x + \log_a y&lt;/math&gt;
#Prove that &lt;math&gt;\log_a x^y = y \log_a x&lt;/math&gt;
#Prove that &lt;math&gt;\log_a x = \frac{\log_b x}{\log_b a}&lt;/math&gt;
#Prove that &lt;math&gt;x^{\log_b y} = y^{\log_b x}&lt;/math&gt;


:[[2.45]]. Show that &lt;math&gt;\lceil \lg(n+1) \rceil = \lfloor \lg n \rfloor +1&lt;/math&gt;

[[2.45|Solution]]


:2.46. Prove that that the binary representation of &lt;math&gt;n \geq 1&lt;/math&gt; has &lt;math&gt;\lfloor \lg_2 n \rfloor&lt;/math&gt; + &lt;math&gt;1&lt;/math&gt; bits.


:[[2.47]]. In one of my research papers I give a comparison-based sorting algorithm that runs in &lt;math&gt;O( n \log (\sqrt n) )&lt;/math&gt;. Given the existence of an &lt;math&gt;\Omega(n \log n)&lt;/math&gt; lower bound for sorting, how can this be possible?
 

[[2.47|Solution]]

===Interview Problems===


:2.48. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; numbers. You must pick a subset &lt;math&gt;S'&lt;/math&gt; of &lt;math&gt;k&lt;/math&gt; numbers from &lt;math&gt;S&lt;/math&gt; such that the probability of each element of &lt;math&gt;S&lt;/math&gt; occurring in &lt;math&gt;S'&lt;/math&gt; is equal (i.e., each is selected with probability &lt;math&gt;k/n&lt;/math&gt;). You may make only one pass over the numbers. What if &lt;math&gt;n&lt;/math&gt; is unknown?


:[[2.49]]. We have 1,000 data items to store on 1,000 nodes. Each node can store copies of exactly three different items. Propose a replication scheme to minimize data loss as nodes fail. What is the expected number of data entries that get lost when three random nodes fail?

[[2.49|Solution]]


:2.50. Consider the following algorithm to find the minimum element in an array of numbers &lt;math&gt;A[0, \ldots, n]&lt;/math&gt;. One extra variable &lt;math&gt;tmp&lt;/math&gt; is allocated to hold the current minimum value. Start from A[0]; "tmp" is compared against &lt;math&gt;A[1]&lt;/math&gt;, 
&lt;math&gt;A[2]&lt;/math&gt;, &lt;math&gt;\ldots&lt;/math&gt;, &lt;math&gt;A[N]&lt;/math&gt; in order. When &lt;math&gt;A[i]&lt;tmp&lt;/math&gt;, &lt;math&gt;tmp = A[i]&lt;/math&gt;. What is the expected number of times that the assignment operation &lt;math&gt;tmp = A[i]&lt;/math&gt; is performed?


:[[2.51]]. You are given ten bags of gold coins. Nine bags contain coins that each weigh 10 grams. One bag contains all false coins that weigh 1 gram less. You must identify this bag in just one weighing. You have a digital balance that reports the weight of what is placed on it.

[[2.51|Solution]]


:2.52. You have eight balls all of the same size. Seven of them weigh the same, and one of them weighs slightly more. How can you find the ball that is heavier by using a balance and only two weightings?


:[[2.53]]. Suppose we start with &lt;math&gt;n&lt;/math&gt; companies that eventually merge into one big company. How many different ways are there for them to merge?

[[2.53|Solution]]


:2.54. Six pirates must divide $300 among themselves. The division is to proceed as follows. The senior pirate proposes a way to divide the money. Then the pirates vote. If the senior pirate gets at least half the votes he wins, and that division remains. If he doesn’t, he is killed and then the next senior-most pirate gets a chance to propose the division. Now tell what will happen and why (i.e. how many pirates survive and how the division is done)? All the pirates are intelligent and the first priority is to stay alive and the next priority is to get as much money as possible.


:[[2.55]]. Reconsider the pirate problem above, where we start with only one indivisible dollar. Who gets the dollar, and how many are killed?

[[2.55|Solution]]


Back to [[Chapter List]]</text>
      <sha1>5ip0o65fa0e2rtuyh1xx9z4rtffemhj</sha1>
    </revision>
    <revision>
      <id>459</id>
      <parentid>265</parentid>
      <timestamp>2020-10-01T18:11:11Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <minor/>
      <comment>Protected "[[Chapter 2]]" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="18662">=Algorithm Analysis=

===Program Analysis===

:[[2.1]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using the Big Oh notation.
   mystery(''n'')
       r:=0
       ''for'' i:=1 ''to'' n-1 ''do''
           ''for'' j:=i+1 ''to'' n ''do''
               ''for'' k:=1 ''to'' j ''do''
                   r:=r+1
        ''return''(r)

[[2.1|Solution]]


:2.2. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    pesky(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    r:=r+1
        ''return''(r)


:[[2.3]]. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
    prestiferous(n)
        r:=0
        ''for'' i:=1 ''to'' n ''do''
            ''for'' j:=1 ''to'' i ''do''
                ''for'' k:=j ''to'' i+j ''do''
                    ''for'' l:=1 ''to'' i+j-k ''do''
                        r:=r+1
        ''return''(r) 

[[2.3|Solution]]


:2.4. What value is returned by the following function? Express your answer as a function of &lt;math&gt;n&lt;/math&gt;. Give the worst-case running time using Big Oh notation.
   conundrum(&lt;math&gt;n&lt;/math&gt;)
       &lt;math&gt;r:=0&lt;/math&gt;
       ''for'' &lt;math&gt;i:=1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;j:=i+1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       ''for'' &lt;math&gt;k:=i+j-1&lt;/math&gt; ''to'' &lt;math&gt;n&lt;/math&gt; ''do''
       &lt;math&gt;r:=r+1&lt;/math&gt;
       ''return''(r)


:[[2.5]]. Consider the following algorithm: (the print operation prints a single asterisk; the operation &lt;math&gt;x = 2x&lt;/math&gt; doubles the value of the variable &lt;math&gt;x&lt;/math&gt;).
    ''for'' &lt;math&gt; k = 1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt;
        &lt;math&gt;x = k&lt;/math&gt;
        ''while'' (&lt;math&gt;x &lt; n&lt;/math&gt;):
           ''print'' '*'
           &lt;math&gt;x = 2x&lt;/math&gt;
:Let &lt;math&gt;f(n)&lt;/math&gt; be the complexity of this algorithm (or equivalently the number of times * is printed). Proivde correct bounds for &lt;math&gt; O(f(n))&lt;/math&gt;, and &lt;math&gt;\Theta(f(n))&lt;/math&gt;, ideally converging on &lt;math&gt;\Theta(f(n))&lt;/math&gt;.

[[2.5|Solution]]


:2.6. Suppose the following algorithm is used to evaluate the polynomial
::::::&lt;math&gt; p(x)=a_n x^n +a_{n-1} x^{n-1}+ \ldots + a_1 x +a_0&lt;/math&gt;
    &lt;math&gt;p:=a_0;&lt;/math&gt;
    &lt;math&gt;xpower:=1;&lt;/math&gt;
    for &lt;math&gt;i:=1&lt;/math&gt; to &lt;math&gt;n&lt;/math&gt; do
    &lt;math&gt;xpower:=x*xpower;&lt;/math&gt;
    &lt;math&gt;p:=p+a_i * xpower&lt;/math&gt;
#How many multiplications are done in the worst-case? How many additions?
#How many multiplications are done on the average?
#Can you improve this algorithm?


:2.7. Prove that the following algorithm for computing the maximum value in an array &lt;math&gt;A[1..n]&lt;/math&gt; is correct.
   max(A)
      &lt;math&gt;m:=A[1]&lt;/math&gt;
      ''for'' &lt;math&gt;i:=2&lt;/math&gt; ''to'' n ''do''
            ''if'' &lt;math&gt;A[i] &gt; m&lt;/math&gt; ''then'' &lt;math&gt;m:=A[i]&lt;/math&gt;
      ''return'' (m)

[[2.7|Solution]]

===Big Oh===


:2.8. True or False?
#Is &lt;math&gt;2^{n+1} = O (2^n)&lt;/math&gt;?
#Is &lt;math&gt;2^{2n} = O(2^n)&lt;/math&gt;?


:[[2.9]]. For each of the following pairs of functions, either &lt;math&gt;f(n )&lt;/math&gt; is in &lt;math&gt;O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)&lt;/math&gt; is in &lt;math&gt;\Omega(g(n))&lt;/math&gt;, or &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;. Determine which relationship is correct and briefly explain why.
#&lt;math&gt;f(n)=\log n^2&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt; + &lt;math&gt;5&lt;/math&gt;
#&lt;math&gt;f(n)=\sqrt n&lt;/math&gt;; &lt;math&gt;g(n)=\log n^2&lt;/math&gt;
#&lt;math&gt;f(n)=\log^2 n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=n&lt;/math&gt;; &lt;math&gt;g(n)=\log^2 n&lt;/math&gt;
#&lt;math&gt;f(n)=n \log n + n&lt;/math&gt;; &lt;math&gt;g(n)=\log n&lt;/math&gt;
#&lt;math&gt;f(n)=10&lt;/math&gt;; &lt;math&gt;g(n)=\log 10&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=10 n^2&lt;/math&gt;
#&lt;math&gt;f(n)=2^n&lt;/math&gt;; &lt;math&gt;g(n)=3^n&lt;/math&gt;

[[2.9|Solution]]


:2.10. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, determine whether &lt;math&gt;f(n) = O(g(n))&lt;/math&gt;, &lt;math&gt;g(n) = O(f(n))&lt;/math&gt;, or both.
#&lt;math&gt;f(n) = (n^2 - n)/2&lt;/math&gt;,  &lt;math&gt;g(n) =6n&lt;/math&gt;
#&lt;math&gt;f(n) = n +2 \sqrt n&lt;/math&gt;, &lt;math&gt;g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = n \log n&lt;/math&gt;, &lt;math&gt;g(n) = n \sqrt n /2&lt;/math&gt;
#&lt;math&gt;f(n) = n + \log n&lt;/math&gt;, &lt;math&gt;g(n) = \sqrt n&lt;/math&gt;
#&lt;math&gt;f(n) = 2(\log n)^2&lt;/math&gt;, &lt;math&gt;g(n) = \log n + 1&lt;/math&gt;
#&lt;math&gt;f(n) = 4n\log n + n&lt;/math&gt;, &lt;math&gt;g(n) = (n^2 - n)/2&lt;/math&gt;


:[[2.11]]. For each of the following functions, which of the following asymptotic bounds hold for &lt;math&gt;f(n) = O(g(n)),\Theta(g(n)),\Omega(g(n))&lt;/math&gt;?
#&lt;math&gt;f(n) = 3n^2, g(n) = n^2&lt;/math&gt;
#&lt;math&gt;f(n) = 2n^4 - 3n^2 + 7, g(n) = n^5&lt;/math&gt;
#&lt;math&gt;f(n) = log n, g(n) = log n + 1/n&lt;/math&gt;
#&lt;math&gt;f(n) = 2^{klog n}, g(n) = n^k&lt;/math&gt;
#&lt;math&gt;f(n) = 2^n, g(n) = 2^{2n}&lt;/math&gt;

[[2.11|Solution]]


:2.12. Prove that &lt;math&gt;n^3 - 3n^2-n+1 = \Theta(n^3)&lt;/math&gt;.


:2.13. Prove that &lt;math&gt;n^2 = O(2^n)&lt;/math&gt;.

[[2.13|Solution]]


:2.14. Prove or disprove: &lt;math&gt;\Theta(n^2) = \Theta(n^2+1)&lt;/math&gt;.


:[[2.15]]. Suppose you have algorithms with the five running times listed below. (Assume these are the exact running times.) How much slower do each of these inputs get when you (a) double the input size, or (b) increase the input size by one?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;

[[2.15|Solution]]


:2.16.  Suppose you have algorithms with the six running times listed below. (Assume these are the exact number of operations performed as a function of input size &lt;math&gt;n&lt;/math&gt;.)Suppose you have a computer that can perform &lt;math&gt;10^10&lt;/math&gt; operations per second. For each algorithm, what is the largest input size n that you can complete within an hour?
::(a) &lt;math&gt;n^2&lt;/math&gt;  (b) &lt;math&gt;n^3&lt;/math&gt;  (c) &lt;math&gt;100n^2&lt;/math&gt;  (d) &lt;math&gt;nlogn&lt;/math&gt;  (e) &lt;math&gt;2^n&lt;/math&gt;  (f) &lt;math&gt;2^{2^n}&lt;/math&gt;


:[[2.17]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, give an appropriate positive constant &lt;math&gt;c&lt;/math&gt; such that &lt;math&gt;f(n) \leq c \cdot g(n)&lt;/math&gt; for all &lt;math&gt;n &gt; 1&lt;/math&gt;.
#&lt;math&gt;f(n)=n^2+n+1&lt;/math&gt;, &lt;math&gt;g(n)=2n^3&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n + n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^2&lt;/math&gt;
#&lt;math&gt;f(n)=n^2-n+1&lt;/math&gt;, &lt;math&gt;g(n)=n^2/2&lt;/math&gt;

[[2.17|Solution]]


:2.18. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n) = O(g_1(n)+g_2(n))&lt;/math&gt;.


:[[2.19]]. Prove that if &lt;math&gt;f_1(N)=\Omega(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=\Omega(g_2(n) &lt;/math&gt;, then &lt;math&gt;f_1(n)+f_2(n)=\Omega(g_1(n)+g_2(n))&lt;/math&gt;.

[[2.19|Solution]]


:2.20. Prove that if &lt;math&gt;f_1(n)=O(g_1(n))&lt;/math&gt; and &lt;math&gt;f_2(n)=O(g_2(n))&lt;/math&gt;, then &lt;math&gt;f_1(n) \cdot f_2(n) = O(g_1(n) \cdot g_2(n))&lt;/math&gt;


:[[2.21]]. Prove for all &lt;math&gt;k \geq 1&lt;/math&gt; and all sets of constants &lt;math&gt;\{a_k, a_{k-1}, \ldots, a_1,a_0\} \in R&lt;/math&gt;, &lt;math&gt; a_k n^k + a_{k-1}n^{k-1}+....+a_1 n + a_0 = O(n^k)&lt;/math&gt;

[[2.21|Solution]]


:2.22. Show that for any real constants &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;, &lt;math&gt;b &gt; 0&lt;/math&gt;
&lt;center&gt;&lt;math&gt;(n + a)^b = \Omega (n^b)&lt;/math&gt;&lt;/center&gt;


:[[2.23]]. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{llll}
n &amp; 2^n &amp; n \lg n &amp; \ln n \\
n-n^3+7n^5 &amp; \lg n &amp; \sqrt n &amp; e^n \\
n^2+\lg n &amp; n^2 &amp; 2^{n-1} &amp;  \lg \lg n \\
n^3 &amp; (\lg n)^2 &amp; n! &amp; n^{1+\varepsilon} where 0&lt; \varepsilon &lt;1
\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.23|Solution]]


:2.24. List the functions below from lowest to highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{llll}
n^{\pi} &amp; \pi^n &amp; \binom{n}{5} &amp; \sqrt{2\sqrt{n}} \\
\binom{n}{n-4} &amp; 2^{log^4n} &amp; n^{5(logn)^2} &amp; n^4\binom{n}{n-4}
\\
\end{array}&lt;/math&gt;
&lt;/center&gt;


:[[2.25]]. List the functions below from lowest to highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{llll}
\sum_{i=1}^n i^i &amp; n^n &amp; (log n)^{log n} &amp; 2^{(log n^2)}\\
n! &amp; 2^{log^4n} &amp; n^{(log n)^2} &amp; n^4 \binom{n}{n-4}\\
\end{array}&lt;/math&gt;
&lt;/center&gt;


[[2.25|Solution]]


:2.26. List the functions below from the lowest to the highest order. If any two or more are of the same order, indicate which.
&lt;center&gt;
&lt;math&gt;\begin{array}{lll}
\sqrt{n} &amp; n &amp; 2^n \\
n \log n &amp;  n - n^3 + 7n^5 &amp;  n^2 + \log n \\
n^2 &amp;  n^3 &amp;  \log n \\
n^{\frac{1}{3}} + \log n &amp; (\log n)^2 &amp;  n! \\
\ln n &amp; \frac{n}{\log n} &amp;  \log \log n \\
({1}/{3})^n &amp;  ({3}/{2})^n &amp;  6 \\
\end{array}&lt;/math&gt;
&lt;/center&gt;


:[[2.27]]. Find two functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt; that satisfy the following relationship. If no such &lt;math&gt;f&lt;/math&gt; and &lt;math&gt;g&lt;/math&gt; exist, write ''None.''
#&lt;math&gt;f(n)=o(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq \Theta(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n)=o(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;
#&lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt; and &lt;math&gt;f(n) \neq O(g(n))&lt;/math&gt;

[[2.27|Solution]]


:2.28. True or False?
#&lt;math&gt;2n^2+1=O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n= O(\log n)&lt;/math&gt;
#&lt;math&gt;\log n = O(\sqrt n)&lt;/math&gt;
#&lt;math&gt;n^2(1 + \sqrt n) = O(n^2 \log n)&lt;/math&gt;
#&lt;math&gt;3n^2 + \sqrt n = O(n^2)&lt;/math&gt;
#&lt;math&gt;\sqrt n \log n= O(n) &lt;/math&gt;
#&lt;math&gt;\log n=O(n^{-1/2})&lt;/math&gt;


:[[2.29]]. For each of the following pairs of functions &lt;math&gt;f(n)&lt;/math&gt; and &lt;math&gt;g(n)&lt;/math&gt;, state whether &lt;math&gt;f(n)=O(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Omega(g(n))&lt;/math&gt;, &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;, or none of the above.
#&lt;math&gt;f(n)=n^2+3n+4&lt;/math&gt;, &lt;math&gt;g(n)=6n+7&lt;/math&gt;
#&lt;math&gt;f(n)=n \sqrt n&lt;/math&gt;, &lt;math&gt;g(n)=n^2-n&lt;/math&gt;
#&lt;math&gt;f(n)=2^n - n^2&lt;/math&gt;, &lt;math&gt;g(n)=n^4+n^2&lt;/math&gt;

[[2.29|Solution]]. 


:2.30. For each of these questions, briefly explain your answer.
::(a) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
::(b) If I prove that an algorithm takes &lt;math&gt;O(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
::(c) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on some inputs?
::(d) If I prove that an algorithm takes &lt;math&gt;\Theta(n^2)&lt;/math&gt; worst-case time, is it possible that it takes &lt;math&gt;O(n)&lt;/math&gt; on all inputs?
::(e) Is the function &lt;math&gt;f(n) = \Theta(n^2)&lt;/math&gt;, where &lt;math&gt;f(n) = 100 n^2&lt;/math&gt; for even &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;f(n) = 20 n^2 - n \log_2 n&lt;/math&gt; for odd &lt;math&gt;n&lt;/math&gt;?


:[[2.31]]. For each of the following, answer ''yes'', ''no'', or ''can't tell''. Explain your reasoning.
::(a) Is &lt;math&gt;3^n = O(2^n)&lt;/math&gt;?
::(b) Is &lt;math&gt;\log 3^n = O( \log 2^n )&lt;/math&gt;?
::(c) Is &lt;math&gt;3^n = \Omega(2^n)&lt;/math&gt;?
::(d) Is &lt;math&gt;\log 3^n = \Omega( \log 2^n )&lt;/math&gt;?

[[2.31|Solution]]


:2.32. For each of the following expressions &lt;math&gt;f(n)&lt;/math&gt; find a simple &lt;math&gt;g(n)&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n {1\over i}&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \lceil {1\over i}\rceil&lt;/math&gt;.
#&lt;math&gt;f(n)=\sum_{i=1}^n \log i&lt;/math&gt;.
#&lt;math&gt;f(n)=\log (n!)&lt;/math&gt;.


:[[2.33]]. Place the following functions into increasing asymptotic order.
::&lt;math&gt;f_1(n) = n^2\log_2n&lt;/math&gt;, &lt;math&gt;f_2(n) = n(\log_2n)^2&lt;/math&gt;, &lt;math&gt;f_3(n) = \sum_{i=0}^n 2^i&lt;/math&gt;, &lt;math&gt;f_4(n) = \log_2(\sum_{i=0}^n 2^i)&lt;/math&gt;.

[[2.33|Solution]]


:2.34. Which of the following are true?
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n-1})&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^n)&lt;/math&gt;.
#&lt;math&gt;\sum_{i=1}^n 3^i = \Theta(3^{n+1})&lt;/math&gt;.


:[[2.35]]. For each of the following functions &lt;math&gt;f&lt;/math&gt; find a simple function &lt;math&gt;g&lt;/math&gt; such that &lt;math&gt;f(n)=\Theta(g(n))&lt;/math&gt;.
#&lt;math&gt;f_1(n)= (1000)2^n + 4^n&lt;/math&gt;.
#&lt;math&gt;f_2(n)= n + n\log n + \sqrt n&lt;/math&gt;.
#&lt;math&gt;f_3(n)= \log (n^{20}) + (\log n)^{10}&lt;/math&gt;.
#&lt;math&gt;f_4(n)= (0.99)^n + n^{100}.&lt;/math&gt;

[[2.35|Solution]]


:2.36. For each pair of expressions &lt;math&gt;(A,B)&lt;/math&gt; below, indicate whether &lt;math&gt;A&lt;/math&gt; is &lt;math&gt;O&lt;/math&gt;, &lt;math&gt;o&lt;/math&gt;, &lt;math&gt;\Omega&lt;/math&gt;, &lt;math&gt;\omega&lt;/math&gt;, or &lt;math&gt;\Theta&lt;/math&gt; of &lt;math&gt;B&lt;/math&gt;.  Note that zero, one or more of these relations may hold for a given pair; list all correct ones.
&lt;br&gt;&lt;center&gt;&lt;math&gt;
\begin{array}{lcc}
        &amp; A                     &amp; B \\
(a)     &amp; n^{100}               &amp; 2^n \\
(b)     &amp; (\lg n)^{12}         &amp; \sqrt{n} \\
(c)     &amp; \sqrt{n}              &amp; n^{\cos (\pi n/8)} \\
(d)     &amp; 10^n                  &amp; 100^n \\
(e)     &amp; n^{\lg n}            &amp; (\lg n)^n \\
(f)     &amp; \lg{(n!)}            &amp; n \lg n
\end{array}
&lt;/math&gt;&lt;/center&gt;

===Summations===


:[[2.37]]. Find an expression for the sum of the &lt;math&gt;i&lt;/math&gt;th row of the following triangle, and prove its correctness. Each entry is the sum of the three entries directly above it. All non existing entries are considered 0.
&lt;center&gt;
&lt;math&gt;\begin{array}{ccccccccc}
&amp;&amp;&amp;&amp;1&amp;&amp;&amp;&amp; \\
&amp;&amp;&amp;1&amp;1&amp;1&amp;&amp;&amp;\\
&amp;&amp;1&amp;2&amp;3&amp;2&amp;1&amp;&amp;\\
&amp;1&amp;3&amp;6&amp;7&amp;6&amp;3&amp;1&amp;\\
1&amp;4&amp;10&amp;16&amp;19&amp;16&amp;10&amp;4&amp;1\\
\end{array}&lt;/math&gt;
&lt;/center&gt;

[[2.37|Solution]]


:2.38. Assume that Christmas has &lt;math&gt;n&lt;/math&gt; days. Exactly how many presents did my ''true love'' send me? (Do some research if you do not understand this question.)


:[[2.39]]

[[2.39|Solution]]


:2.40. Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n do
      for j=i to 2*i do
         output ''foobar''
&lt;/tt&gt;
:Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as a summation (actually two nested summations).
#Simplify the summation.  Show your work.


:[[2.41]].Consider the following code fragment.
&lt;tt&gt;
   for i=1 to n/2 do
      for j=i to n-i do
         for k=1 to j do
            output ''foobar''
&lt;/tt&gt;
:Assume &lt;math&gt;n&lt;/math&gt; is even. Let &lt;math&gt;T(n)&lt;/math&gt; denote the number of times `foobar' is printed as a function of &lt;math&gt;n&lt;/math&gt;.
#Express &lt;math&gt;T(n)&lt;/math&gt; as three nested summations.
#Simplify the summation.  Show your work.

[[2.41|Solution]]


:2.42. When you first learned to multiply numbers, you were told that &lt;math&gt;x \times y&lt;/math&gt; means adding &lt;math&gt;x&lt;/math&gt; a total of &lt;math&gt;y&lt;/math&gt; times, so &lt;math&gt;5 \times 4 = 5+5+5+5 = 20&lt;/math&gt;. What is the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers in base &lt;math&gt;b&lt;/math&gt; (people work in base 10, of course, while computers work in base 2) using the repeated addition method, as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;. Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time. (Hint: how big can &lt;math&gt;y&lt;/math&gt; be as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt;?)


:[[2.43]]. In grade school, you learned to multiply long numbers on a digit-by-digit basis, so that &lt;math&gt;127 \times 211 = 127 \times 1 + 127 \times 10 + 127 \times 200 = 26,397&lt;/math&gt;. Analyze the time complexity of multiplying two &lt;math&gt;n&lt;/math&gt;-digit numbers with this method as a function of &lt;math&gt;n&lt;/math&gt; (assume constant base size). Assume that single-digit by single-digit addition or multiplication takes &lt;math&gt;O(1)&lt;/math&gt; time.

[[2.43|Solution]]

===Logartihms===


:2.44. Prove the following identities on logarithms:
#Prove that &lt;math&gt;\log_a (xy) = \log_a x + \log_a y&lt;/math&gt;
#Prove that &lt;math&gt;\log_a x^y = y \log_a x&lt;/math&gt;
#Prove that &lt;math&gt;\log_a x = \frac{\log_b x}{\log_b a}&lt;/math&gt;
#Prove that &lt;math&gt;x^{\log_b y} = y^{\log_b x}&lt;/math&gt;


:[[2.45]]. Show that &lt;math&gt;\lceil \lg(n+1) \rceil = \lfloor \lg n \rfloor +1&lt;/math&gt;

[[2.45|Solution]]


:2.46. Prove that that the binary representation of &lt;math&gt;n \geq 1&lt;/math&gt; has &lt;math&gt;\lfloor \lg_2 n \rfloor&lt;/math&gt; + &lt;math&gt;1&lt;/math&gt; bits.


:[[2.47]]. In one of my research papers I give a comparison-based sorting algorithm that runs in &lt;math&gt;O( n \log (\sqrt n) )&lt;/math&gt;. Given the existence of an &lt;math&gt;\Omega(n \log n)&lt;/math&gt; lower bound for sorting, how can this be possible?
 

[[2.47|Solution]]

===Interview Problems===


:2.48. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; numbers. You must pick a subset &lt;math&gt;S'&lt;/math&gt; of &lt;math&gt;k&lt;/math&gt; numbers from &lt;math&gt;S&lt;/math&gt; such that the probability of each element of &lt;math&gt;S&lt;/math&gt; occurring in &lt;math&gt;S'&lt;/math&gt; is equal (i.e., each is selected with probability &lt;math&gt;k/n&lt;/math&gt;). You may make only one pass over the numbers. What if &lt;math&gt;n&lt;/math&gt; is unknown?


:[[2.49]]. We have 1,000 data items to store on 1,000 nodes. Each node can store copies of exactly three different items. Propose a replication scheme to minimize data loss as nodes fail. What is the expected number of data entries that get lost when three random nodes fail?

[[2.49|Solution]]


:2.50. Consider the following algorithm to find the minimum element in an array of numbers &lt;math&gt;A[0, \ldots, n]&lt;/math&gt;. One extra variable &lt;math&gt;tmp&lt;/math&gt; is allocated to hold the current minimum value. Start from A[0]; "tmp" is compared against &lt;math&gt;A[1]&lt;/math&gt;, 
&lt;math&gt;A[2]&lt;/math&gt;, &lt;math&gt;\ldots&lt;/math&gt;, &lt;math&gt;A[N]&lt;/math&gt; in order. When &lt;math&gt;A[i]&lt;tmp&lt;/math&gt;, &lt;math&gt;tmp = A[i]&lt;/math&gt;. What is the expected number of times that the assignment operation &lt;math&gt;tmp = A[i]&lt;/math&gt; is performed?


:[[2.51]]. You are given ten bags of gold coins. Nine bags contain coins that each weigh 10 grams. One bag contains all false coins that weigh 1 gram less. You must identify this bag in just one weighing. You have a digital balance that reports the weight of what is placed on it.

[[2.51|Solution]]


:2.52. You have eight balls all of the same size. Seven of them weigh the same, and one of them weighs slightly more. How can you find the ball that is heavier by using a balance and only two weightings?


:[[2.53]]. Suppose we start with &lt;math&gt;n&lt;/math&gt; companies that eventually merge into one big company. How many different ways are there for them to merge?

[[2.53|Solution]]


:2.54. Six pirates must divide $300 among themselves. The division is to proceed as follows. The senior pirate proposes a way to divide the money. Then the pirates vote. If the senior pirate gets at least half the votes he wins, and that division remains. If he doesn’t, he is killed and then the next senior-most pirate gets a chance to propose the division. Now tell what will happen and why (i.e. how many pirates survive and how the division is done)? All the pirates are intelligent and the first priority is to stay alive and the next priority is to get as much money as possible.


:[[2.55]]. Reconsider the pirate problem above, where we start with only one indivisible dollar. Who gets the dollar, and how many are killed?

[[2.55|Solution]]


Back to [[Chapter List]]</text>
      <sha1>5ip0o65fa0e2rtuyh1xx9z4rtffemhj</sha1>
    </revision>
  </page>
  <page>
    <title>Chapter 3</title>
    <ns>0</ns>
    <id>6</id>
    <revision>
      <id>15</id>
      <timestamp>2020-08-23T19:33:57Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Problems   Back to [[Chapter List]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="35">Problems


Back to [[Chapter List]]</text>
      <sha1>95722ndl4ewzic1ak6z8g4auy0tqhc6</sha1>
    </revision>
    <revision>
      <id>100</id>
      <parentid>15</parentid>
      <timestamp>2020-09-07T17:36:34Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="607">=Data Structure=

===Stacks, Queues, and Lists===

[[3.1]]

3.2

[[3.3]]

3.4

[[3.5]]

3.6

[[3.7]]


===Elementray Data Structures===

3.8

[[3.9]]

3.10

===Trees and Other Dictionary Structures===

[[3.11]]


3.12

[[3.13]]

3.14

[[3.15]]

3.16

[[3.17]]

3.18

[[3.19]]

3.20

[[3.21]]

===Applications of Tree Structures===

3.22

[[3.23]]

3.24

[[3.25]]

3.26

[[3.27]]

3.28

[[3.29]]

3.30

[[3.31]]

===Implementation Projects===

3.32 

[[3.33]]

===Interview Problems===

3.34

[[3.35]]

3.36

[[3.37]]

3.38

[[3.39]]

3.40

[[3.41]]

3.42

[[3.43]]

3.44

[[3.45]]


Back to [[Chapter List]]</text>
      <sha1>jnn3pqdfxqxfjbijyl26zomuicoiecm</sha1>
    </revision>
    <revision>
      <id>101</id>
      <parentid>100</parentid>
      <timestamp>2020-09-07T17:36:58Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Trees and Other Dictionary Structures */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="616">=Data Structure=

===Stacks, Queues, and Lists===

[[3.1]]

3.2

[[3.3]]

3.4

[[3.5]]

3.6

[[3.7]]


===Elementray Data Structures===

3.8

[[3.9]]

3.10

===Trees and Other Dictionary Structures===

[[3.11]]


3.12


[[3.13]]


3.14


[[3.15]]


3.16


[[3.17]]


3.18


[[3.19]]


3.20


[[3.21]]

===Applications of Tree Structures===

3.22

[[3.23]]

3.24

[[3.25]]

3.26

[[3.27]]

3.28

[[3.29]]

3.30

[[3.31]]

===Implementation Projects===

3.32 

[[3.33]]

===Interview Problems===

3.34

[[3.35]]

3.36

[[3.37]]

3.38

[[3.39]]

3.40

[[3.41]]

3.42

[[3.43]]

3.44

[[3.45]]


Back to [[Chapter List]]</text>
      <sha1>r6jic3q77g3clxcvcr7dy266hvt3nxh</sha1>
    </revision>
    <revision>
      <id>102</id>
      <parentid>101</parentid>
      <timestamp>2020-09-07T17:37:11Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Stacks, Queues, and Lists */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="622">=Data Structure=

===Stacks, Queues, and Lists===

[[3.1]]


3.2
 

[[3.3]]


3.4


[[3.5]]


3.6


[[3.7]]

===Elementray Data Structures===

3.8

[[3.9]]

3.10

===Trees and Other Dictionary Structures===

[[3.11]]


3.12


[[3.13]]


3.14


[[3.15]]


3.16


[[3.17]]


3.18


[[3.19]]


3.20


[[3.21]]

===Applications of Tree Structures===

3.22

[[3.23]]

3.24

[[3.25]]

3.26

[[3.27]]

3.28

[[3.29]]

3.30

[[3.31]]

===Implementation Projects===

3.32 

[[3.33]]

===Interview Problems===

3.34

[[3.35]]

3.36

[[3.37]]

3.38

[[3.39]]

3.40

[[3.41]]

3.42

[[3.43]]

3.44

[[3.45]]


Back to [[Chapter List]]</text>
      <sha1>o13buuhn9rxqg3b7ik6k1rd35k2mqo1</sha1>
    </revision>
    <revision>
      <id>103</id>
      <parentid>102</parentid>
      <timestamp>2020-09-07T17:37:46Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Elementray Data Structures */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="624">=Data Structure=

===Stacks, Queues, and Lists===

[[3.1]]


3.2
 

[[3.3]]


3.4


[[3.5]]


3.6


[[3.7]]

===Elementary Data Structures===

3.8


[[3.9]]


3.10

===Trees and Other Dictionary Structures===

[[3.11]]


3.12


[[3.13]]


3.14


[[3.15]]


3.16


[[3.17]]


3.18


[[3.19]]


3.20


[[3.21]]

===Applications of Tree Structures===

3.22

[[3.23]]

3.24

[[3.25]]

3.26

[[3.27]]

3.28

[[3.29]]

3.30

[[3.31]]

===Implementation Projects===

3.32 

[[3.33]]

===Interview Problems===

3.34

[[3.35]]

3.36

[[3.37]]

3.38

[[3.39]]

3.40

[[3.41]]

3.42

[[3.43]]

3.44

[[3.45]]


Back to [[Chapter List]]</text>
      <sha1>9dxl9hgzze355zywhlihfwtywoe8kxn</sha1>
    </revision>
    <revision>
      <id>104</id>
      <parentid>103</parentid>
      <timestamp>2020-09-07T17:38:02Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Applications of Tree Structures */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="633">=Data Structure=

===Stacks, Queues, and Lists===

[[3.1]]


3.2
 

[[3.3]]


3.4


[[3.5]]


3.6


[[3.7]]

===Elementary Data Structures===

3.8


[[3.9]]


3.10

===Trees and Other Dictionary Structures===

[[3.11]]


3.12


[[3.13]]


3.14


[[3.15]]


3.16


[[3.17]]


3.18


[[3.19]]


3.20


[[3.21]]

===Applications of Tree Structures===

3.22


[[3.23]]


3.24


[[3.25]]


3.26


[[3.27]]


3.28


[[3.29]]


3.30


[[3.31]]

===Implementation Projects===

3.32 

[[3.33]]

===Interview Problems===

3.34

[[3.35]]

3.36

[[3.37]]

3.38

[[3.39]]

3.40

[[3.41]]

3.42

[[3.43]]

3.44

[[3.45]]


Back to [[Chapter List]]</text>
      <sha1>j2umdd82wrpb2558duo3oypbqiz1x4a</sha1>
    </revision>
    <revision>
      <id>105</id>
      <parentid>104</parentid>
      <timestamp>2020-09-07T17:38:11Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Implementation Projects */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="634">=Data Structure=

===Stacks, Queues, and Lists===

[[3.1]]


3.2
 

[[3.3]]


3.4


[[3.5]]


3.6


[[3.7]]

===Elementary Data Structures===

3.8


[[3.9]]


3.10

===Trees and Other Dictionary Structures===

[[3.11]]


3.12


[[3.13]]


3.14


[[3.15]]


3.16


[[3.17]]


3.18


[[3.19]]


3.20


[[3.21]]

===Applications of Tree Structures===

3.22


[[3.23]]


3.24


[[3.25]]


3.26


[[3.27]]


3.28


[[3.29]]


3.30


[[3.31]]

===Implementation Projects===

3.32 


[[3.33]]

===Interview Problems===

3.34

[[3.35]]

3.36

[[3.37]]

3.38

[[3.39]]

3.40

[[3.41]]

3.42

[[3.43]]

3.44

[[3.45]]


Back to [[Chapter List]]</text>
      <sha1>ryg6oedgwo5y8zsl79vkmztmkzt1vvm</sha1>
    </revision>
    <revision>
      <id>106</id>
      <parentid>105</parentid>
      <timestamp>2020-09-07T17:38:27Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Interview Problems */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="645">=Data Structure=

===Stacks, Queues, and Lists===

[[3.1]]


3.2
 

[[3.3]]


3.4


[[3.5]]


3.6


[[3.7]]

===Elementary Data Structures===

3.8


[[3.9]]


3.10

===Trees and Other Dictionary Structures===

[[3.11]]


3.12


[[3.13]]


3.14


[[3.15]]


3.16


[[3.17]]


3.18


[[3.19]]


3.20


[[3.21]]

===Applications of Tree Structures===

3.22


[[3.23]]


3.24


[[3.25]]


3.26


[[3.27]]


3.28


[[3.29]]


3.30


[[3.31]]

===Implementation Projects===

3.32 


[[3.33]]

===Interview Problems===

3.34


[[3.35]]


3.36


[[3.37]]


3.38


[[3.39]]


3.40


[[3.41]]


3.42


[[3.43]]


3.44


[[3.45]]


Back to [[Chapter List]]</text>
      <sha1>8yw8eeptayxmx58p1oeoujivxsgqttn</sha1>
    </revision>
    <revision>
      <id>254</id>
      <parentid>106</parentid>
      <timestamp>2020-09-14T20:38:22Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Stacks, Queues, and Lists */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="2881">=Data Structure=

===Stacks, Queues, and Lists===

[[3.1]]. A common problem for compilers and text editors is determining whether the parentheses in a string are balanced and properly nested. For example, the string &lt;math&gt;((())())()&lt;/math&gt; contains properly nested pairs of parentheses, which the strings &lt;math&gt;)()(&lt;/math&gt; and &lt;math&gt;())&lt;/math&gt;
do not. Give an algorithm that returns true if a string contains properly nested and balanced parentheses, and false if otherwise. For full credit, identify the position of the first offending parenthesis if the string is not properly nested and balanced.
[[3.1|Solution]]


3.2. Give an algorithm that takes a string &lt;math&gt;S&lt;/math&gt; consisting of opening and closing parentheses, say )()(())()()))())))(, and finds the length of the longest balanced parentheses in &lt;math&gt;S&lt;/math&gt;, which is 12 in the example above. (Hint: The solution is not necessarily a contiguous run of parenthesis from &lt;math&gt;S&lt;/math&gt;.)
 

[[3.3]]. Give an algorithm to reverse the direction of a given singly linked list. In other words, after the reversal all pointers should now point backwards. Your algorithm should take linear time.
[[3.3|Solution]]


3.4. Design a stack &lt;math&gt;S&lt;/math&gt; that supports ''S.push(x)'', ''S.pop()'', and ''S.findmin()'', which returns the minimum element of &lt;math&gt;S&lt;/math&gt;. All operations should run in constant time.


[[3.5]]. We have seen how dynamic arrays enable arrays to grow while still achieving constant-time amortized performance. This problem concerns extending dynamic arrays to let them both grow and shrink on demand.
:(a) Consider an underflow strategy that cuts the array size in half whenever the array falls below half full. Give an example sequence of insertions and deletions where this strategy gives a bad amortized cost.
:(b) Then, give a better underflow strategy than that suggested above, one that achieves constant amortized cost per deletion.
[[3.5|Solution]]


3.6. Suppose you seek to maintain the contents of a refrigerator so as to minimize food spoilage. What data structure should you use, and how should you use it?


[[3.7]]. Work out the details of supporting constant-time deletion from a singly linked list as per the footnote from page 79, ideally to an actual implementation. Support the other operations as efficiently as possible. 
[[3.7|Solution]]

===Elementary Data Structures===

3.8


[[3.9]]


3.10

===Trees and Other Dictionary Structures===

[[3.11]]


3.12


[[3.13]]


3.14


[[3.15]]


3.16


[[3.17]]


3.18


[[3.19]]


3.20


[[3.21]]

===Applications of Tree Structures===

3.22


[[3.23]]


3.24


[[3.25]]


3.26


[[3.27]]


3.28


[[3.29]]


3.30


[[3.31]]

===Implementation Projects===

3.32 


[[3.33]]

===Interview Problems===

3.34


[[3.35]]


3.36


[[3.37]]


3.38


[[3.39]]


3.40


[[3.41]]


3.42


[[3.43]]


3.44


[[3.45]]


Back to [[Chapter List]]</text>
      <sha1>osx1fnmvzfzsewaxrkh0rih4k63zs3u</sha1>
    </revision>
    <revision>
      <id>255</id>
      <parentid>254</parentid>
      <timestamp>2020-09-14T20:39:23Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Stacks, Queues, and Lists */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="2888">=Data Structure=

===Stacks, Queues, and Lists===

:[[3.1]]. A common problem for compilers and text editors is determining whether the parentheses in a string are balanced and properly nested. For example, the string &lt;math&gt;((())())()&lt;/math&gt; contains properly nested pairs of parentheses, which the strings &lt;math&gt;)()(&lt;/math&gt; and &lt;math&gt;())&lt;/math&gt; do not. Give an algorithm that returns true if a string contains properly nested and balanced parentheses, and false if otherwise. For full credit, identify the position of the first offending parenthesis if the string is not properly nested and balanced.
[[3.1|Solution]]


:3.2. Give an algorithm that takes a string &lt;math&gt;S&lt;/math&gt; consisting of opening and closing parentheses, say )()(())()()))())))(, and finds the length of the longest balanced parentheses in &lt;math&gt;S&lt;/math&gt;, which is 12 in the example above. (Hint: The solution is not necessarily a contiguous run of parenthesis from &lt;math&gt;S&lt;/math&gt;.)
 

:[[3.3]]. Give an algorithm to reverse the direction of a given singly linked list. In other words, after the reversal all pointers should now point backwards. Your algorithm should take linear time.
[[3.3|Solution]]


:3.4. Design a stack &lt;math&gt;S&lt;/math&gt; that supports ''S.push(x)'', ''S.pop()'', and ''S.findmin()'', which returns the minimum element of &lt;math&gt;S&lt;/math&gt;. All operations should run in constant time.


:[[3.5]]. We have seen how dynamic arrays enable arrays to grow while still achieving constant-time amortized performance. This problem concerns extending dynamic arrays to let them both grow and shrink on demand.
:(a) Consider an underflow strategy that cuts the array size in half whenever the array falls below half full. Give an example sequence of insertions and deletions where this strategy gives a bad amortized cost.
:(b) Then, give a better underflow strategy than that suggested above, one that achieves constant amortized cost per deletion.
[[3.5|Solution]]


:3.6. Suppose you seek to maintain the contents of a refrigerator so as to minimize food spoilage. What data structure should you use, and how should you use it?


:[[3.7]]. Work out the details of supporting constant-time deletion from a singly linked list as per the footnote from page 79, ideally to an actual implementation. Support the other operations as efficiently as possible. 
[[3.7|Solution]]

===Elementary Data Structures===

3.8


[[3.9]]


3.10

===Trees and Other Dictionary Structures===

[[3.11]]


3.12


[[3.13]]


3.14


[[3.15]]


3.16


[[3.17]]


3.18


[[3.19]]


3.20


[[3.21]]

===Applications of Tree Structures===

3.22


[[3.23]]


3.24


[[3.25]]


3.26


[[3.27]]


3.28


[[3.29]]


3.30


[[3.31]]

===Implementation Projects===

3.32 


[[3.33]]

===Interview Problems===

3.34


[[3.35]]


3.36


[[3.37]]


3.38


[[3.39]]


3.40


[[3.41]]


3.42


[[3.43]]


3.44


[[3.45]]


Back to [[Chapter List]]</text>
      <sha1>php3rj9qr82x88wtbh4hjwxzoawswow</sha1>
    </revision>
    <revision>
      <id>256</id>
      <parentid>255</parentid>
      <timestamp>2020-09-14T20:42:56Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Elementary Data Structures */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="3923">=Data Structure=

===Stacks, Queues, and Lists===

:[[3.1]]. A common problem for compilers and text editors is determining whether the parentheses in a string are balanced and properly nested. For example, the string &lt;math&gt;((())())()&lt;/math&gt; contains properly nested pairs of parentheses, which the strings &lt;math&gt;)()(&lt;/math&gt; and &lt;math&gt;())&lt;/math&gt; do not. Give an algorithm that returns true if a string contains properly nested and balanced parentheses, and false if otherwise. For full credit, identify the position of the first offending parenthesis if the string is not properly nested and balanced.
[[3.1|Solution]]


:3.2. Give an algorithm that takes a string &lt;math&gt;S&lt;/math&gt; consisting of opening and closing parentheses, say )()(())()()))())))(, and finds the length of the longest balanced parentheses in &lt;math&gt;S&lt;/math&gt;, which is 12 in the example above. (Hint: The solution is not necessarily a contiguous run of parenthesis from &lt;math&gt;S&lt;/math&gt;.)
 

:[[3.3]]. Give an algorithm to reverse the direction of a given singly linked list. In other words, after the reversal all pointers should now point backwards. Your algorithm should take linear time.
[[3.3|Solution]]


:3.4. Design a stack &lt;math&gt;S&lt;/math&gt; that supports ''S.push(x)'', ''S.pop()'', and ''S.findmin()'', which returns the minimum element of &lt;math&gt;S&lt;/math&gt;. All operations should run in constant time.


:[[3.5]]. We have seen how dynamic arrays enable arrays to grow while still achieving constant-time amortized performance. This problem concerns extending dynamic arrays to let them both grow and shrink on demand.
:(a) Consider an underflow strategy that cuts the array size in half whenever the array falls below half full. Give an example sequence of insertions and deletions where this strategy gives a bad amortized cost.
:(b) Then, give a better underflow strategy than that suggested above, one that achieves constant amortized cost per deletion.
[[3.5|Solution]]


:3.6. Suppose you seek to maintain the contents of a refrigerator so as to minimize food spoilage. What data structure should you use, and how should you use it?


:[[3.7]]. Work out the details of supporting constant-time deletion from a singly linked list as per the footnote from page 79, ideally to an actual implementation. Support the other operations as efficiently as possible. 
[[3.7|Solution]]

===Elementary Data Structures===

:3.8. Tic-tac-toe is a game played on an &lt;math&gt;n * n&lt;/math&gt; board (typically &lt;math&gt;n = 3&lt;/math&gt;) where two players take consecutive turns placing “O” and “X” marks onto the board cells. The game is won if n consecutive “O” or ‘X” marks are placed in a row, column, or diagonal. Create a data structure with &lt;math&gt;O(n)&lt;/math&gt; space that accepts a sequence of moves, and reports in constant time whether the last move won the game.


:[[3.9]]. Write a function which, given a sequence of digits 2–9 and a dictionary of &lt;math&gt;n&lt;/math&gt; words, reports all words described by this sequence when typed in on a standard telephone keypad. For the sequence 269 you should return any, box, boy, and cow, among other words.
[[3.9|Solution]]


:3.10. Two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; are anagrams if the letters of &lt;math&gt;X&lt;/math&gt; can be rearranged to form &lt;math&gt;Y&lt;/math&gt; . For example, silent/listen, and incest/insect are anagrams. Give an efficient algorithm to determine whether strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; are anagrams.

===Trees and Other Dictionary Structures===

[[3.11]]


3.12


[[3.13]]


3.14


[[3.15]]


3.16


[[3.17]]


3.18


[[3.19]]


3.20


[[3.21]]

===Applications of Tree Structures===

3.22


[[3.23]]


3.24


[[3.25]]


3.26


[[3.27]]


3.28


[[3.29]]


3.30


[[3.31]]

===Implementation Projects===

3.32 


[[3.33]]

===Interview Problems===

3.34


[[3.35]]


3.36


[[3.37]]


3.38


[[3.39]]


3.40


[[3.41]]


3.42


[[3.43]]


3.44


[[3.45]]


Back to [[Chapter List]]</text>
      <sha1>a8st29rjpetqbnjqhwrxc6dug4e1jp5</sha1>
    </revision>
    <revision>
      <id>257</id>
      <parentid>256</parentid>
      <timestamp>2020-09-14T20:48:34Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Interview Problems */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="5860">=Data Structure=

===Stacks, Queues, and Lists===

:[[3.1]]. A common problem for compilers and text editors is determining whether the parentheses in a string are balanced and properly nested. For example, the string &lt;math&gt;((())())()&lt;/math&gt; contains properly nested pairs of parentheses, which the strings &lt;math&gt;)()(&lt;/math&gt; and &lt;math&gt;())&lt;/math&gt; do not. Give an algorithm that returns true if a string contains properly nested and balanced parentheses, and false if otherwise. For full credit, identify the position of the first offending parenthesis if the string is not properly nested and balanced.
[[3.1|Solution]]


:3.2. Give an algorithm that takes a string &lt;math&gt;S&lt;/math&gt; consisting of opening and closing parentheses, say )()(())()()))())))(, and finds the length of the longest balanced parentheses in &lt;math&gt;S&lt;/math&gt;, which is 12 in the example above. (Hint: The solution is not necessarily a contiguous run of parenthesis from &lt;math&gt;S&lt;/math&gt;.)
 

:[[3.3]]. Give an algorithm to reverse the direction of a given singly linked list. In other words, after the reversal all pointers should now point backwards. Your algorithm should take linear time.
[[3.3|Solution]]


:3.4. Design a stack &lt;math&gt;S&lt;/math&gt; that supports ''S.push(x)'', ''S.pop()'', and ''S.findmin()'', which returns the minimum element of &lt;math&gt;S&lt;/math&gt;. All operations should run in constant time.


:[[3.5]]. We have seen how dynamic arrays enable arrays to grow while still achieving constant-time amortized performance. This problem concerns extending dynamic arrays to let them both grow and shrink on demand.
:(a) Consider an underflow strategy that cuts the array size in half whenever the array falls below half full. Give an example sequence of insertions and deletions where this strategy gives a bad amortized cost.
:(b) Then, give a better underflow strategy than that suggested above, one that achieves constant amortized cost per deletion.
[[3.5|Solution]]


:3.6. Suppose you seek to maintain the contents of a refrigerator so as to minimize food spoilage. What data structure should you use, and how should you use it?


:[[3.7]]. Work out the details of supporting constant-time deletion from a singly linked list as per the footnote from page 79, ideally to an actual implementation. Support the other operations as efficiently as possible. 
[[3.7|Solution]]

===Elementary Data Structures===

:3.8. Tic-tac-toe is a game played on an &lt;math&gt;n * n&lt;/math&gt; board (typically &lt;math&gt;n = 3&lt;/math&gt;) where two players take consecutive turns placing “O” and “X” marks onto the board cells. The game is won if n consecutive “O” or ‘X” marks are placed in a row, column, or diagonal. Create a data structure with &lt;math&gt;O(n)&lt;/math&gt; space that accepts a sequence of moves, and reports in constant time whether the last move won the game.


:[[3.9]]. Write a function which, given a sequence of digits 2–9 and a dictionary of &lt;math&gt;n&lt;/math&gt; words, reports all words described by this sequence when typed in on a standard telephone keypad. For the sequence 269 you should return any, box, boy, and cow, among other words.
[[3.9|Solution]]


:3.10. Two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; are anagrams if the letters of &lt;math&gt;X&lt;/math&gt; can be rearranged to form &lt;math&gt;Y&lt;/math&gt; . For example, silent/listen, and incest/insect are anagrams. Give an efficient algorithm to determine whether strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; are anagrams.

===Trees and Other Dictionary Structures===

[[3.11]]


3.12


[[3.13]]


3.14


[[3.15]]


3.16


[[3.17]]


3.18


[[3.19]]


3.20


[[3.21]]

===Applications of Tree Structures===

3.22


[[3.23]]


3.24


[[3.25]]


3.26


[[3.27]]


3.28


[[3.29]]


3.30


[[3.31]]

===Implementation Projects===

3.32 


[[3.33]]

===Interview Problems===

:3.34. What method would you use to look up a word in a dictionary?


:[[3.35]]. Imagine you have a closet full of shirts. What can you do to organize your shirts for easy retrieval?
[[3.35|Solution]]


:3.36. Write a function to find the middle node of a singly linked list.


:[[3.37]]. [4] Write a function to determine whether two binary trees are identical. Identical trees have the same key value at each position and the same structure.
[[3.37|Solution]]


:3.38. Write a program to convert a binary search tree into a linked list.


:[[3.39]]. Implement an algorithm to reverse a linked list. Now do it without recursion.
[[3.39|Solution]]


:3.40. What is the best data structure for maintaining URLs that have been visited by a web crawler? Give an algorithm to test whether a given URL has already been visited, optimizing both space and time.


:[[3.41]]. You are given a search string and a magazine. You seek to generate all the characters in the search string by cutting them out from the magazine. Give an algorithm to efficiently determine whether the magazine contains all the letters in the search string.
[[3.41|Solution]]


:3.42. Reverse the words in a sentence—that is, “My name is Chris” becomes “Chris is name My.” Optimize for time and space.


:[[3.43]]. Determine whether a linked list contains a loop as quickly as possible without using any extra storage. Also, identify the location of the loop.
[[3.43|Solution]]


:3.44. You have an unordered array &lt;math&gt;X&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers. Find the array &lt;math&gt;M&lt;/math&gt; containing &lt;math&gt;n&lt;/math&gt; elements where &lt;math&gt;M_i&lt;/math&gt; is the product of all integers in &lt;math&gt;X&lt;/math&gt; except for &lt;math&gt;X_i&lt;/math&gt;. You may not use division. You can use extra memory. (Hint: there are solutions faster than &lt;math&gt;O(n^2)&lt;/math&gt;.)


:[[3.45]]. Give an algorithm for finding an ordered word pair (e.g. “New York”) occurring with the greatest frequency in a given webpage. Which data structures would you use? Optimize both time and space.
[[3.45|Solution]]


Back to [[Chapter List]]</text>
      <sha1>450cs5up0zeit2tfo8pbxpvdx3zldzn</sha1>
    </revision>
    <revision>
      <id>258</id>
      <parentid>257</parentid>
      <timestamp>2020-09-18T14:26:48Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Implementation Projects */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="6738">=Data Structure=

===Stacks, Queues, and Lists===

:[[3.1]]. A common problem for compilers and text editors is determining whether the parentheses in a string are balanced and properly nested. For example, the string &lt;math&gt;((())())()&lt;/math&gt; contains properly nested pairs of parentheses, which the strings &lt;math&gt;)()(&lt;/math&gt; and &lt;math&gt;())&lt;/math&gt; do not. Give an algorithm that returns true if a string contains properly nested and balanced parentheses, and false if otherwise. For full credit, identify the position of the first offending parenthesis if the string is not properly nested and balanced.
[[3.1|Solution]]


:3.2. Give an algorithm that takes a string &lt;math&gt;S&lt;/math&gt; consisting of opening and closing parentheses, say )()(())()()))())))(, and finds the length of the longest balanced parentheses in &lt;math&gt;S&lt;/math&gt;, which is 12 in the example above. (Hint: The solution is not necessarily a contiguous run of parenthesis from &lt;math&gt;S&lt;/math&gt;.)
 

:[[3.3]]. Give an algorithm to reverse the direction of a given singly linked list. In other words, after the reversal all pointers should now point backwards. Your algorithm should take linear time.
[[3.3|Solution]]


:3.4. Design a stack &lt;math&gt;S&lt;/math&gt; that supports ''S.push(x)'', ''S.pop()'', and ''S.findmin()'', which returns the minimum element of &lt;math&gt;S&lt;/math&gt;. All operations should run in constant time.


:[[3.5]]. We have seen how dynamic arrays enable arrays to grow while still achieving constant-time amortized performance. This problem concerns extending dynamic arrays to let them both grow and shrink on demand.
:(a) Consider an underflow strategy that cuts the array size in half whenever the array falls below half full. Give an example sequence of insertions and deletions where this strategy gives a bad amortized cost.
:(b) Then, give a better underflow strategy than that suggested above, one that achieves constant amortized cost per deletion.
[[3.5|Solution]]


:3.6. Suppose you seek to maintain the contents of a refrigerator so as to minimize food spoilage. What data structure should you use, and how should you use it?


:[[3.7]]. Work out the details of supporting constant-time deletion from a singly linked list as per the footnote from page 79, ideally to an actual implementation. Support the other operations as efficiently as possible. 
[[3.7|Solution]]

===Elementary Data Structures===

:3.8. Tic-tac-toe is a game played on an &lt;math&gt;n * n&lt;/math&gt; board (typically &lt;math&gt;n = 3&lt;/math&gt;) where two players take consecutive turns placing “O” and “X” marks onto the board cells. The game is won if n consecutive “O” or ‘X” marks are placed in a row, column, or diagonal. Create a data structure with &lt;math&gt;O(n)&lt;/math&gt; space that accepts a sequence of moves, and reports in constant time whether the last move won the game.


:[[3.9]]. Write a function which, given a sequence of digits 2–9 and a dictionary of &lt;math&gt;n&lt;/math&gt; words, reports all words described by this sequence when typed in on a standard telephone keypad. For the sequence 269 you should return any, box, boy, and cow, among other words.
[[3.9|Solution]]


:3.10. Two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; are anagrams if the letters of &lt;math&gt;X&lt;/math&gt; can be rearranged to form &lt;math&gt;Y&lt;/math&gt; . For example, silent/listen, and incest/insect are anagrams. Give an efficient algorithm to determine whether strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; are anagrams.

===Trees and Other Dictionary Structures===

[[3.11]]


3.12


[[3.13]]


3.14


[[3.15]]


3.16


[[3.17]]


3.18


[[3.19]]


3.20


[[3.21]]

===Applications of Tree Structures===

3.22


[[3.23]]


3.24


[[3.25]]


3.26


[[3.27]]


3.28


[[3.29]]


3.30


[[3.31]]

===Implementation Projects===

3.32. Implement versions of several different dictionary data structures, such as linked lists, binary trees, balanced binary search trees, and hash tables. Conduct experiments to assess the relative performance of these data structures in a simple application that reads a large text file and reports exactly one instance of each word that appears within it. This application can be efficiently implemented by maintaining a dictionary of all distinct words that have appeared thus far in the text and inserting/reporting each new word that appears in the stream. Write a brief report with your conclusions.


[[3.33]]. A Caesar shift (see Section 21.6 (page 697)) is a very simple class of ciphers for secret messages. Unfortunately, they can be broken using statistical properties of English. Develop a program capable of decrypting Caesar shifts of sufficiently long texts.
[[3.33|Solution]]

===Interview Problems===

:3.34. What method would you use to look up a word in a dictionary?


:[[3.35]]. Imagine you have a closet full of shirts. What can you do to organize your shirts for easy retrieval?
[[3.35|Solution]]


:3.36. Write a function to find the middle node of a singly linked list.


:[[3.37]]. [4] Write a function to determine whether two binary trees are identical. Identical trees have the same key value at each position and the same structure.
[[3.37|Solution]]


:3.38. Write a program to convert a binary search tree into a linked list.


:[[3.39]]. Implement an algorithm to reverse a linked list. Now do it without recursion.
[[3.39|Solution]]


:3.40. What is the best data structure for maintaining URLs that have been visited by a web crawler? Give an algorithm to test whether a given URL has already been visited, optimizing both space and time.


:[[3.41]]. You are given a search string and a magazine. You seek to generate all the characters in the search string by cutting them out from the magazine. Give an algorithm to efficiently determine whether the magazine contains all the letters in the search string.
[[3.41|Solution]]


:3.42. Reverse the words in a sentence—that is, “My name is Chris” becomes “Chris is name My.” Optimize for time and space.


:[[3.43]]. Determine whether a linked list contains a loop as quickly as possible without using any extra storage. Also, identify the location of the loop.
[[3.43|Solution]]


:3.44. You have an unordered array &lt;math&gt;X&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers. Find the array &lt;math&gt;M&lt;/math&gt; containing &lt;math&gt;n&lt;/math&gt; elements where &lt;math&gt;M_i&lt;/math&gt; is the product of all integers in &lt;math&gt;X&lt;/math&gt; except for &lt;math&gt;X_i&lt;/math&gt;. You may not use division. You can use extra memory. (Hint: there are solutions faster than &lt;math&gt;O(n^2)&lt;/math&gt;.)


:[[3.45]]. Give an algorithm for finding an ordered word pair (e.g. “New York”) occurring with the greatest frequency in a given webpage. Which data structures would you use? Optimize both time and space.
[[3.45|Solution]]


Back to [[Chapter List]]</text>
      <sha1>e9w6lijji4mu788yubly02cja1m3s9y</sha1>
    </revision>
    <revision>
      <id>259</id>
      <parentid>258</parentid>
      <timestamp>2020-09-18T14:27:02Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Implementation Projects */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="6740">=Data Structure=

===Stacks, Queues, and Lists===

:[[3.1]]. A common problem for compilers and text editors is determining whether the parentheses in a string are balanced and properly nested. For example, the string &lt;math&gt;((())())()&lt;/math&gt; contains properly nested pairs of parentheses, which the strings &lt;math&gt;)()(&lt;/math&gt; and &lt;math&gt;())&lt;/math&gt; do not. Give an algorithm that returns true if a string contains properly nested and balanced parentheses, and false if otherwise. For full credit, identify the position of the first offending parenthesis if the string is not properly nested and balanced.
[[3.1|Solution]]


:3.2. Give an algorithm that takes a string &lt;math&gt;S&lt;/math&gt; consisting of opening and closing parentheses, say )()(())()()))())))(, and finds the length of the longest balanced parentheses in &lt;math&gt;S&lt;/math&gt;, which is 12 in the example above. (Hint: The solution is not necessarily a contiguous run of parenthesis from &lt;math&gt;S&lt;/math&gt;.)
 

:[[3.3]]. Give an algorithm to reverse the direction of a given singly linked list. In other words, after the reversal all pointers should now point backwards. Your algorithm should take linear time.
[[3.3|Solution]]


:3.4. Design a stack &lt;math&gt;S&lt;/math&gt; that supports ''S.push(x)'', ''S.pop()'', and ''S.findmin()'', which returns the minimum element of &lt;math&gt;S&lt;/math&gt;. All operations should run in constant time.


:[[3.5]]. We have seen how dynamic arrays enable arrays to grow while still achieving constant-time amortized performance. This problem concerns extending dynamic arrays to let them both grow and shrink on demand.
:(a) Consider an underflow strategy that cuts the array size in half whenever the array falls below half full. Give an example sequence of insertions and deletions where this strategy gives a bad amortized cost.
:(b) Then, give a better underflow strategy than that suggested above, one that achieves constant amortized cost per deletion.
[[3.5|Solution]]


:3.6. Suppose you seek to maintain the contents of a refrigerator so as to minimize food spoilage. What data structure should you use, and how should you use it?


:[[3.7]]. Work out the details of supporting constant-time deletion from a singly linked list as per the footnote from page 79, ideally to an actual implementation. Support the other operations as efficiently as possible. 
[[3.7|Solution]]

===Elementary Data Structures===

:3.8. Tic-tac-toe is a game played on an &lt;math&gt;n * n&lt;/math&gt; board (typically &lt;math&gt;n = 3&lt;/math&gt;) where two players take consecutive turns placing “O” and “X” marks onto the board cells. The game is won if n consecutive “O” or ‘X” marks are placed in a row, column, or diagonal. Create a data structure with &lt;math&gt;O(n)&lt;/math&gt; space that accepts a sequence of moves, and reports in constant time whether the last move won the game.


:[[3.9]]. Write a function which, given a sequence of digits 2–9 and a dictionary of &lt;math&gt;n&lt;/math&gt; words, reports all words described by this sequence when typed in on a standard telephone keypad. For the sequence 269 you should return any, box, boy, and cow, among other words.
[[3.9|Solution]]


:3.10. Two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; are anagrams if the letters of &lt;math&gt;X&lt;/math&gt; can be rearranged to form &lt;math&gt;Y&lt;/math&gt; . For example, silent/listen, and incest/insect are anagrams. Give an efficient algorithm to determine whether strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; are anagrams.

===Trees and Other Dictionary Structures===

[[3.11]]


3.12


[[3.13]]


3.14


[[3.15]]


3.16


[[3.17]]


3.18


[[3.19]]


3.20


[[3.21]]

===Applications of Tree Structures===

3.22


[[3.23]]


3.24


[[3.25]]


3.26


[[3.27]]


3.28


[[3.29]]


3.30


[[3.31]]

===Implementation Projects===

:3.32. Implement versions of several different dictionary data structures, such as linked lists, binary trees, balanced binary search trees, and hash tables. Conduct experiments to assess the relative performance of these data structures in a simple application that reads a large text file and reports exactly one instance of each word that appears within it. This application can be efficiently implemented by maintaining a dictionary of all distinct words that have appeared thus far in the text and inserting/reporting each new word that appears in the stream. Write a brief report with your conclusions.


:[[3.33]]. A Caesar shift (see Section 21.6 (page 697)) is a very simple class of ciphers for secret messages. Unfortunately, they can be broken using statistical properties of English. Develop a program capable of decrypting Caesar shifts of sufficiently long texts.
[[3.33|Solution]]

===Interview Problems===

:3.34. What method would you use to look up a word in a dictionary?


:[[3.35]]. Imagine you have a closet full of shirts. What can you do to organize your shirts for easy retrieval?
[[3.35|Solution]]


:3.36. Write a function to find the middle node of a singly linked list.


:[[3.37]]. [4] Write a function to determine whether two binary trees are identical. Identical trees have the same key value at each position and the same structure.
[[3.37|Solution]]


:3.38. Write a program to convert a binary search tree into a linked list.


:[[3.39]]. Implement an algorithm to reverse a linked list. Now do it without recursion.
[[3.39|Solution]]


:3.40. What is the best data structure for maintaining URLs that have been visited by a web crawler? Give an algorithm to test whether a given URL has already been visited, optimizing both space and time.


:[[3.41]]. You are given a search string and a magazine. You seek to generate all the characters in the search string by cutting them out from the magazine. Give an algorithm to efficiently determine whether the magazine contains all the letters in the search string.
[[3.41|Solution]]


:3.42. Reverse the words in a sentence—that is, “My name is Chris” becomes “Chris is name My.” Optimize for time and space.


:[[3.43]]. Determine whether a linked list contains a loop as quickly as possible without using any extra storage. Also, identify the location of the loop.
[[3.43|Solution]]


:3.44. You have an unordered array &lt;math&gt;X&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers. Find the array &lt;math&gt;M&lt;/math&gt; containing &lt;math&gt;n&lt;/math&gt; elements where &lt;math&gt;M_i&lt;/math&gt; is the product of all integers in &lt;math&gt;X&lt;/math&gt; except for &lt;math&gt;X_i&lt;/math&gt;. You may not use division. You can use extra memory. (Hint: there are solutions faster than &lt;math&gt;O(n^2)&lt;/math&gt;.)


:[[3.45]]. Give an algorithm for finding an ordered word pair (e.g. “New York”) occurring with the greatest frequency in a given webpage. Which data structures would you use? Optimize both time and space.
[[3.45|Solution]]


Back to [[Chapter List]]</text>
      <sha1>bm8xcjzjcdaouufj9348lrix5iyupc9</sha1>
    </revision>
    <revision>
      <id>260</id>
      <parentid>259</parentid>
      <timestamp>2020-09-18T14:43:16Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Trees and Other Dictionary Structures */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="10060">=Data Structure=

===Stacks, Queues, and Lists===

:[[3.1]]. A common problem for compilers and text editors is determining whether the parentheses in a string are balanced and properly nested. For example, the string &lt;math&gt;((())())()&lt;/math&gt; contains properly nested pairs of parentheses, which the strings &lt;math&gt;)()(&lt;/math&gt; and &lt;math&gt;())&lt;/math&gt; do not. Give an algorithm that returns true if a string contains properly nested and balanced parentheses, and false if otherwise. For full credit, identify the position of the first offending parenthesis if the string is not properly nested and balanced.
[[3.1|Solution]]


:3.2. Give an algorithm that takes a string &lt;math&gt;S&lt;/math&gt; consisting of opening and closing parentheses, say )()(())()()))())))(, and finds the length of the longest balanced parentheses in &lt;math&gt;S&lt;/math&gt;, which is 12 in the example above. (Hint: The solution is not necessarily a contiguous run of parenthesis from &lt;math&gt;S&lt;/math&gt;.)
 

:[[3.3]]. Give an algorithm to reverse the direction of a given singly linked list. In other words, after the reversal all pointers should now point backwards. Your algorithm should take linear time.
[[3.3|Solution]]


:3.4. Design a stack &lt;math&gt;S&lt;/math&gt; that supports ''S.push(x)'', ''S.pop()'', and ''S.findmin()'', which returns the minimum element of &lt;math&gt;S&lt;/math&gt;. All operations should run in constant time.


:[[3.5]]. We have seen how dynamic arrays enable arrays to grow while still achieving constant-time amortized performance. This problem concerns extending dynamic arrays to let them both grow and shrink on demand.
:(a) Consider an underflow strategy that cuts the array size in half whenever the array falls below half full. Give an example sequence of insertions and deletions where this strategy gives a bad amortized cost.
:(b) Then, give a better underflow strategy than that suggested above, one that achieves constant amortized cost per deletion.
[[3.5|Solution]]


:3.6. Suppose you seek to maintain the contents of a refrigerator so as to minimize food spoilage. What data structure should you use, and how should you use it?


:[[3.7]]. Work out the details of supporting constant-time deletion from a singly linked list as per the footnote from page 79, ideally to an actual implementation. Support the other operations as efficiently as possible. 
[[3.7|Solution]]

===Elementary Data Structures===

:3.8. Tic-tac-toe is a game played on an &lt;math&gt;n * n&lt;/math&gt; board (typically &lt;math&gt;n = 3&lt;/math&gt;) where two players take consecutive turns placing “O” and “X” marks onto the board cells. The game is won if n consecutive “O” or ‘X” marks are placed in a row, column, or diagonal. Create a data structure with &lt;math&gt;O(n)&lt;/math&gt; space that accepts a sequence of moves, and reports in constant time whether the last move won the game.


:[[3.9]]. Write a function which, given a sequence of digits 2–9 and a dictionary of &lt;math&gt;n&lt;/math&gt; words, reports all words described by this sequence when typed in on a standard telephone keypad. For the sequence 269 you should return any, box, boy, and cow, among other words.
[[3.9|Solution]]


:3.10. Two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; are anagrams if the letters of &lt;math&gt;X&lt;/math&gt; can be rearranged to form &lt;math&gt;Y&lt;/math&gt; . For example, silent/listen, and incest/insect are anagrams. Give an efficient algorithm to determine whether strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; are anagrams.

===Trees and Other Dictionary Structures===

:[[3.11]]. Design a dictionary data structure in which search, insertion, and deletion can all be processed in &lt;math&gt;O(1)&lt;/math&gt; time in the worst case. You may assume the set elements are integers drawn from a finite set &lt;math&gt;1, 2, .., n&lt;/math&gt;, and initialization can take &lt;math&gt;O(n)&lt;/math&gt; time.
[[3.11|Solution]]


:3.12. The maximum depth of a binary tree is the number of nodes on the path from the root down to the most distant leaf node. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm to find the maximum depth of a binary tree with &lt;math&gt;n&lt;/math&gt; nodes.


:[[3.13]]. Two elements of a binary search tree have been swapped by mistake. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm to identify these two elements so they can be swapped back.
[[3.13|Solution]]


:3.14. Given two binary search trees, merge them into a doubly linked list in sorted order.


:[[3.15]]. Describe an &lt;math&gt;O(n)&lt;/math&gt;-time algorithm that takes an &lt;math&gt;n&lt;/math&gt;-node binary search tree and constructs an equivalent height-balanced binary search tree. In a height-balanced binary search tree, the difference between the height of the left and right subtrees of every node is never more than 1.
[[3.15|Solution]]


:3.16. Find the storage efficiency ratio (the ratio of data space over total space) for each of the following binary tree implementations on n nodes:
:(a) All nodes store data, two child pointers, and a parent pointer. The data field requires 4 bytes and each pointer requires 4 bytes.
:(b) Only leaf nodes store data; internal nodes store two child pointers. The data field requires four bytes and each pointer requires two bytes.


:[[3.17]]. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm that determines whether a given &lt;math&gt;n&lt;/math&gt;-node binary tree is height-balanced (see Problem 3-15).
[[3.17|Solution]]


:3.18. Describe how to modify any balanced tree data structure such that search, insert, delete, minimum, and maximum still take &lt;math&gt;O(log n)&lt;/math&gt; time each, but successor and predecessor now take &lt;math&gt;O(1)&lt;/math&gt; time each. Which operations have to be modified to support this?


:[[3.19]]. Suppose you have access to a balanced dictionary data structure that supports each of the operations search, insert, delete, minimum, maximum, successor, and predecessor in &lt;math&gt;O(log n)&lt;/math&gt; time. Explain how to modify the insert and delete operations so they still take &lt;math&gt;O(log n)&lt;/math&gt; but now minimum and maximum take &lt;math&gt;O(1)&lt;/math&gt; time. (Hint: think in terms of using the abstract dictionary operations, instead of mucking about with pointers and the like.)
[[3.19|Solution]]


:3.20. Design a data structure to support the following operations:
:• ''insert''(&lt;math&gt;x,T&lt;/math&gt;) – Insert item &lt;math&gt;x&lt;/math&gt; into the set &lt;math&gt;T&lt;/math&gt;.
:• ''delete''(&lt;math&gt;k,T&lt;/math&gt;) – Delete the &lt;math&gt;k&lt;/math&gt;th smallest element from &lt;math&gt;T&lt;/math&gt;.
:• ''member''(&lt;math&gt;x,T&lt;/math&gt;) – Return true iff &lt;math&gt;x \in T&lt;/math&gt;.
:All operations must take &lt;math&gt;O(log n)&lt;/math&gt; time on an &lt;math&gt;n&lt;/math&gt;-element set.


:[[3.21]]. A ''concatenate operation'' takes two sets &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt;, where every key in &lt;math&gt;S_1&lt;/math&gt; is smaller than any key in &lt;math&gt;S_2&lt;/math&gt;, and merges them. Give an algorithm to concatenate two binary search trees into one binary search tree. The worst-case running time should be &lt;math&gt;O(h)&lt;/math&gt;, where &lt;math&gt;h&lt;/math&gt; is the maximal height of the two trees.
[[3.21|Solution]]

===Applications of Tree Structures===

3.22


[[3.23]]


3.24


[[3.25]]


3.26


[[3.27]]


3.28


[[3.29]]


3.30


[[3.31]]

===Implementation Projects===

:3.32. Implement versions of several different dictionary data structures, such as linked lists, binary trees, balanced binary search trees, and hash tables. Conduct experiments to assess the relative performance of these data structures in a simple application that reads a large text file and reports exactly one instance of each word that appears within it. This application can be efficiently implemented by maintaining a dictionary of all distinct words that have appeared thus far in the text and inserting/reporting each new word that appears in the stream. Write a brief report with your conclusions.


:[[3.33]]. A Caesar shift (see Section 21.6 (page 697)) is a very simple class of ciphers for secret messages. Unfortunately, they can be broken using statistical properties of English. Develop a program capable of decrypting Caesar shifts of sufficiently long texts.
[[3.33|Solution]]

===Interview Problems===

:3.34. What method would you use to look up a word in a dictionary?


:[[3.35]]. Imagine you have a closet full of shirts. What can you do to organize your shirts for easy retrieval?
[[3.35|Solution]]


:3.36. Write a function to find the middle node of a singly linked list.


:[[3.37]]. [4] Write a function to determine whether two binary trees are identical. Identical trees have the same key value at each position and the same structure.
[[3.37|Solution]]


:3.38. Write a program to convert a binary search tree into a linked list.


:[[3.39]]. Implement an algorithm to reverse a linked list. Now do it without recursion.
[[3.39|Solution]]


:3.40. What is the best data structure for maintaining URLs that have been visited by a web crawler? Give an algorithm to test whether a given URL has already been visited, optimizing both space and time.


:[[3.41]]. You are given a search string and a magazine. You seek to generate all the characters in the search string by cutting them out from the magazine. Give an algorithm to efficiently determine whether the magazine contains all the letters in the search string.
[[3.41|Solution]]


:3.42. Reverse the words in a sentence—that is, “My name is Chris” becomes “Chris is name My.” Optimize for time and space.


:[[3.43]]. Determine whether a linked list contains a loop as quickly as possible without using any extra storage. Also, identify the location of the loop.
[[3.43|Solution]]


:3.44. You have an unordered array &lt;math&gt;X&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers. Find the array &lt;math&gt;M&lt;/math&gt; containing &lt;math&gt;n&lt;/math&gt; elements where &lt;math&gt;M_i&lt;/math&gt; is the product of all integers in &lt;math&gt;X&lt;/math&gt; except for &lt;math&gt;X_i&lt;/math&gt;. You may not use division. You can use extra memory. (Hint: there are solutions faster than &lt;math&gt;O(n^2)&lt;/math&gt;.)


:[[3.45]]. Give an algorithm for finding an ordered word pair (e.g. “New York”) occurring with the greatest frequency in a given webpage. Which data structures would you use? Optimize both time and space.
[[3.45|Solution]]


Back to [[Chapter List]]</text>
      <sha1>36s4tiqfo0hxj55qm1p2pdljc2c8yp5</sha1>
    </revision>
    <revision>
      <id>261</id>
      <parentid>260</parentid>
      <timestamp>2020-09-18T15:09:44Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Applications of Tree Structures */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="16104">=Data Structure=

===Stacks, Queues, and Lists===

:[[3.1]]. A common problem for compilers and text editors is determining whether the parentheses in a string are balanced and properly nested. For example, the string &lt;math&gt;((())())()&lt;/math&gt; contains properly nested pairs of parentheses, which the strings &lt;math&gt;)()(&lt;/math&gt; and &lt;math&gt;())&lt;/math&gt; do not. Give an algorithm that returns true if a string contains properly nested and balanced parentheses, and false if otherwise. For full credit, identify the position of the first offending parenthesis if the string is not properly nested and balanced.
[[3.1|Solution]]


:3.2. Give an algorithm that takes a string &lt;math&gt;S&lt;/math&gt; consisting of opening and closing parentheses, say )()(())()()))())))(, and finds the length of the longest balanced parentheses in &lt;math&gt;S&lt;/math&gt;, which is 12 in the example above. (Hint: The solution is not necessarily a contiguous run of parenthesis from &lt;math&gt;S&lt;/math&gt;.)
 

:[[3.3]]. Give an algorithm to reverse the direction of a given singly linked list. In other words, after the reversal all pointers should now point backwards. Your algorithm should take linear time.
[[3.3|Solution]]


:3.4. Design a stack &lt;math&gt;S&lt;/math&gt; that supports ''S.push(x)'', ''S.pop()'', and ''S.findmin()'', which returns the minimum element of &lt;math&gt;S&lt;/math&gt;. All operations should run in constant time.


:[[3.5]]. We have seen how dynamic arrays enable arrays to grow while still achieving constant-time amortized performance. This problem concerns extending dynamic arrays to let them both grow and shrink on demand.
:(a) Consider an underflow strategy that cuts the array size in half whenever the array falls below half full. Give an example sequence of insertions and deletions where this strategy gives a bad amortized cost.
:(b) Then, give a better underflow strategy than that suggested above, one that achieves constant amortized cost per deletion.
[[3.5|Solution]]


:3.6. Suppose you seek to maintain the contents of a refrigerator so as to minimize food spoilage. What data structure should you use, and how should you use it?


:[[3.7]]. Work out the details of supporting constant-time deletion from a singly linked list as per the footnote from page 79, ideally to an actual implementation. Support the other operations as efficiently as possible. 
[[3.7|Solution]]

===Elementary Data Structures===

:3.8. Tic-tac-toe is a game played on an &lt;math&gt;n * n&lt;/math&gt; board (typically &lt;math&gt;n = 3&lt;/math&gt;) where two players take consecutive turns placing “O” and “X” marks onto the board cells. The game is won if n consecutive “O” or ‘X” marks are placed in a row, column, or diagonal. Create a data structure with &lt;math&gt;O(n)&lt;/math&gt; space that accepts a sequence of moves, and reports in constant time whether the last move won the game.


:[[3.9]]. Write a function which, given a sequence of digits 2–9 and a dictionary of &lt;math&gt;n&lt;/math&gt; words, reports all words described by this sequence when typed in on a standard telephone keypad. For the sequence 269 you should return any, box, boy, and cow, among other words.
[[3.9|Solution]]


:3.10. Two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; are anagrams if the letters of &lt;math&gt;X&lt;/math&gt; can be rearranged to form &lt;math&gt;Y&lt;/math&gt; . For example, silent/listen, and incest/insect are anagrams. Give an efficient algorithm to determine whether strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; are anagrams.

===Trees and Other Dictionary Structures===

:[[3.11]]. Design a dictionary data structure in which search, insertion, and deletion can all be processed in &lt;math&gt;O(1)&lt;/math&gt; time in the worst case. You may assume the set elements are integers drawn from a finite set &lt;math&gt;1, 2, .., n&lt;/math&gt;, and initialization can take &lt;math&gt;O(n)&lt;/math&gt; time.
[[3.11|Solution]]


:3.12. The maximum depth of a binary tree is the number of nodes on the path from the root down to the most distant leaf node. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm to find the maximum depth of a binary tree with &lt;math&gt;n&lt;/math&gt; nodes.


:[[3.13]]. Two elements of a binary search tree have been swapped by mistake. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm to identify these two elements so they can be swapped back.
[[3.13|Solution]]


:3.14. Given two binary search trees, merge them into a doubly linked list in sorted order.


:[[3.15]]. Describe an &lt;math&gt;O(n)&lt;/math&gt;-time algorithm that takes an &lt;math&gt;n&lt;/math&gt;-node binary search tree and constructs an equivalent height-balanced binary search tree. In a height-balanced binary search tree, the difference between the height of the left and right subtrees of every node is never more than 1.
[[3.15|Solution]]


:3.16. Find the storage efficiency ratio (the ratio of data space over total space) for each of the following binary tree implementations on n nodes:
:(a) All nodes store data, two child pointers, and a parent pointer. The data field requires 4 bytes and each pointer requires 4 bytes.
:(b) Only leaf nodes store data; internal nodes store two child pointers. The data field requires four bytes and each pointer requires two bytes.


:[[3.17]]. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm that determines whether a given &lt;math&gt;n&lt;/math&gt;-node binary tree is height-balanced (see Problem 3-15).
[[3.17|Solution]]


:3.18. Describe how to modify any balanced tree data structure such that search, insert, delete, minimum, and maximum still take &lt;math&gt;O(log n)&lt;/math&gt; time each, but successor and predecessor now take &lt;math&gt;O(1)&lt;/math&gt; time each. Which operations have to be modified to support this?


:[[3.19]]. Suppose you have access to a balanced dictionary data structure that supports each of the operations search, insert, delete, minimum, maximum, successor, and predecessor in &lt;math&gt;O(log n)&lt;/math&gt; time. Explain how to modify the insert and delete operations so they still take &lt;math&gt;O(log n)&lt;/math&gt; but now minimum and maximum take &lt;math&gt;O(1)&lt;/math&gt; time. (Hint: think in terms of using the abstract dictionary operations, instead of mucking about with pointers and the like.)
[[3.19|Solution]]


:3.20. Design a data structure to support the following operations:
:• ''insert''(&lt;math&gt;x,T&lt;/math&gt;) – Insert item &lt;math&gt;x&lt;/math&gt; into the set &lt;math&gt;T&lt;/math&gt;.
:• ''delete''(&lt;math&gt;k,T&lt;/math&gt;) – Delete the &lt;math&gt;k&lt;/math&gt;th smallest element from &lt;math&gt;T&lt;/math&gt;.
:• ''member''(&lt;math&gt;x,T&lt;/math&gt;) – Return true iff &lt;math&gt;x \in T&lt;/math&gt;.
:All operations must take &lt;math&gt;O(log n)&lt;/math&gt; time on an &lt;math&gt;n&lt;/math&gt;-element set.


:[[3.21]]. A ''concatenate operation'' takes two sets &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt;, where every key in &lt;math&gt;S_1&lt;/math&gt; is smaller than any key in &lt;math&gt;S_2&lt;/math&gt;, and merges them. Give an algorithm to concatenate two binary search trees into one binary search tree. The worst-case running time should be &lt;math&gt;O(h)&lt;/math&gt;, where &lt;math&gt;h&lt;/math&gt; is the maximal height of the two trees.
[[3.21|Solution]]

===Applications of Tree Structures===

:3.22. Design a data structure that supports the following two operations:
:• ''insert''(&lt;math&gt;x&lt;/math&gt;) – Insert item &lt;math&gt;x&lt;/math&gt; from the data stream to the data structure.
:• ''median''() – Return the median of all elements so far.
:All operations must take &lt;math&gt;O(log n)&lt;/math&gt; time on an &lt;math&gt;n&lt;/math&gt;-element set.


:[[3.23]]. Assume we are given a standard dictionary (balanced binary search tree) defined on a set of &lt;math&gt;n&lt;/math&gt; strings, each of length at most &lt;math&gt;l&lt;/math&gt;. We seek to print out all strings beginning with a particular prefix &lt;math&gt;p&lt;/math&gt;. Show how to do this in &lt;math&gt;O(ml log n)&lt;/math&gt; time, where &lt;math&gt;m&lt;/math&gt; is the number of strings.
[[3.23|Solution]]


:3.24. An array &lt;math&gt;A&lt;/math&gt; is called &lt;math&gt;k&lt;/math&gt;-unique if it does not contain a pair of duplicate elements within &lt;math&gt;k&lt;/math&gt; positions of each other, that is, there is no &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; such that &lt;math&gt;A[i] = A[j]&lt;/math&gt; and &lt;math&gt;|j - i| \leq k&lt;/math&gt;. Design a worst-case &lt;math&gt;O(n log k)&lt;/math&gt; algorithm to test if &lt;math&gt;A&lt;/math&gt; is &lt;math&gt;k&lt;/math&gt;-unique.


:[[3.25]]. In the ''bin-packing problem'', we are given &lt;math&gt;n&lt;/math&gt; objects, each weighing at most 1 kilogram. Our goal is to find the smallest number of bins that will hold the &lt;math&gt;n&lt;/math&gt; objects, with each bin holding 1 kilogram at most.
:• The ''best-fit heuristic'' for bin packing is as follows. Consider the objects in the order in which they are given. For each object, place it into the partially filled bin with the smallest amount of extra room after the object is inserted. If no such bin exists, start a new bin. Design an algorithm that implements the best-fit heuristic (taking as input the &lt;math&gt;n&lt;/math&gt; weights &lt;math&gt;w_1, w_2, ..., w_n&lt;/math&gt; and outputting the number of bins used) in &lt;math&gt;O(n log n)&lt;/math&gt; time.
:• Repeat the above using the ''worst-fit heuristic'', where we put the next object into the partially filled bin with the largest amount of extra room after the object is inserted.
[[3.25|Solution]]


:3.26. Suppose that we are given a sequence of &lt;math&gt;n&lt;/math&gt; values &lt;math&gt;x_1, x_2, ..., x_n&lt;/math&gt; and seek to quickly answer repeated queries of the form: given &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt;, find the smallest value in &lt;math&gt;x_i, . . . , x_j&lt;/math&gt;.
:(a) Design a data structure that uses &lt;math&gt;O(n^2)&lt;/math&gt; space and answers queries in &lt;math&gt;O(1)&lt;/math&gt; time.
:(b) Design a data structure that uses &lt;math&gt;O(n)&lt;/math&gt; space and answers queries in &lt;math&gt;O(log n)&lt;/math&gt; time. For partial credit, your data structure can use &lt;math&gt;O(n log n)&lt;/math&gt; space and have &lt;math&gt;O(log n)&lt;/math&gt; query time.


:[[3.27]]. Suppose you are given an input set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, and a black box that if given any sequence of integers and an integer &lt;math&gt;k&lt;/math&gt; instantly and correctly answers whether there is a subset of the input sequence whose sum is exactly &lt;math&gt;k&lt;/math&gt;. Show how to use the black box &lt;math&gt;O(n)&lt;/math&gt; times to find a subset of &lt;math&gt;S&lt;/math&gt; that adds up to &lt;math&gt;k&lt;/math&gt;.
[[3.27|Solution]]


:3.28. Let &lt;math&gt;A[1..n]&lt;/math&gt; be an array of real numbers. Design an algorithm to perform any sequence of the following operations:
:• ''Add''(&lt;math&gt;i,y&lt;/math&gt;) – Add the value &lt;math&gt;y&lt;/math&gt; to the &lt;math&gt;i&lt;/math&gt;th number.
:• ''Partial-sum''(&lt;math&gt;i&lt;/math&gt;) – Return the sum of the first &lt;math&gt;i&lt;/math&gt; numbers, that is, &lt;math&gt;\sum_{j=1}^i A[j]&lt;/math&gt;.
:There are no insertions or deletions; the only change is to the values of the numbers. Each operation should take &lt;math&gt;O(log n)&lt;/math&gt; steps. You may use one additional array of size &lt;math&gt;n&lt;/math&gt; as a work space.


:[[3.29]]. Extend the data structure of the previous problem to support insertions and deletions. Each element now has both a ''key'' and a ''value''. An element is accessed by its key, but the addition operation is applied to the values. The ''Partial_sum'' operation is different.
:• 'Add''(&lt;math&gt;k,y&lt;/math&gt;) – Add the value &lt;math&gt;y&lt;/math&gt; to the item with key &lt;math&gt;k&lt;/math&gt;.
:• ''Insert''(&lt;math&gt;k,y&lt;/math&gt;) – Insert a new item with key &lt;math&gt;k&lt;/math&gt; and value &lt;math&gt;y&lt;/math&gt;.
:• ''Delete''(&lt;math&gt;k&lt;/math&gt;) – Delete the item with key &lt;math&gt;k&lt;/math&gt;.
:• ''Partial-sum''(&lt;math&gt;k&lt;/math&gt;) – Return the sum of all the elements currently in the set whose key is less than &lt;math&gt;k&lt;/math&gt;, that is, &lt;math&gt;\sum_{i &lt; k} x_i&lt;/math&gt;. 
:The worst-case running time should still be &lt;math&gt;O(n log n)&lt;/math&gt; for any sequence of &lt;math&gt;O(n)&lt;/math&gt; operations.
[[3.29|Solution]]


:3.30. You are consulting for a hotel that has &lt;math&gt;n&lt;/math&gt; one-bed rooms. When a guest checks in, they ask for a room whose number is in the range &lt;math&gt;[l, h]&lt;/math&gt;. Propose a data structure that supports the following data operations in the allotted time:
:(a) ''Initialize''(&lt;math&gt;n&lt;/math&gt;): Initialize the data structure for empty rooms numbered &lt;math&gt;1, 2, . . . , n&lt;/math&gt;, in polynomial time.
:(b) ''Count''(&lt;math&gt;l, h&lt;/math&gt;): Return the number of available rooms in &lt;math&gt;[l, h]&lt;/math&gt;, in &lt;math&gt;O(log n)&lt;/math&gt; time.
:(c) ''Checkin''(&lt;math&gt;l, h&lt;/math&gt;): In &lt;math&gt;O(log n)&lt;/math&gt; time, return the first empty room in &lt;math&gt;[l, h]&lt;/math&gt; and mark it occupied, or return NIL if all the rooms in &lt;math&gt;[l, h]&lt;/math&gt; are occupied.
:(d) ''Checkout''(&lt;math&gt;x&lt;/math&gt;): Mark room &lt;math&gt;x&lt;/math&gt; as unoccupied, in &lt;math&gt;O(log n)&lt;/math&gt; time.


:[[3.31]]. Design a data structure that allows one to search, insert, and delete an integer &lt;math&gt;X&lt;/math&gt; in &lt;math&gt;O(1)&lt;/math&gt; time (i.e., constant time, independent of the total number of integers stored). Assume that &lt;math&gt;1 \leq X \leq n&lt;/math&gt; and that there are &lt;math&gt;m + n&lt;/math&gt; units of space available, where &lt;math&gt;m&lt;/math&gt; is the maximum number of integers that can be in the table at any one time. (Hint: use two arrays &lt;math&gt;A[1..n]&lt;/math&gt; and &lt;math&gt;B[1..m]&lt;/math&gt;.) You are not allowed to initialize either &lt;math&gt;A&lt;/math&gt; or &lt;math&gt;B&lt;/math&gt;, as that would take &lt;math&gt;O(m)&lt;/math&gt; or &lt;math&gt;O(n)&lt;/math&gt; operations. This means the arrays are full of random garbage to begin with, so you must be very careful.
[[3.31|Solution]]

===Implementation Projects===

:3.32. Implement versions of several different dictionary data structures, such as linked lists, binary trees, balanced binary search trees, and hash tables. Conduct experiments to assess the relative performance of these data structures in a simple application that reads a large text file and reports exactly one instance of each word that appears within it. This application can be efficiently implemented by maintaining a dictionary of all distinct words that have appeared thus far in the text and inserting/reporting each new word that appears in the stream. Write a brief report with your conclusions.


:[[3.33]]. A Caesar shift (see Section 21.6 (page 697)) is a very simple class of ciphers for secret messages. Unfortunately, they can be broken using statistical properties of English. Develop a program capable of decrypting Caesar shifts of sufficiently long texts.
[[3.33|Solution]]

===Interview Problems===

:3.34. What method would you use to look up a word in a dictionary?


:[[3.35]]. Imagine you have a closet full of shirts. What can you do to organize your shirts for easy retrieval?
[[3.35|Solution]]


:3.36. Write a function to find the middle node of a singly linked list.


:[[3.37]]. [4] Write a function to determine whether two binary trees are identical. Identical trees have the same key value at each position and the same structure.
[[3.37|Solution]]


:3.38. Write a program to convert a binary search tree into a linked list.


:[[3.39]]. Implement an algorithm to reverse a linked list. Now do it without recursion.
[[3.39|Solution]]


:3.40. What is the best data structure for maintaining URLs that have been visited by a web crawler? Give an algorithm to test whether a given URL has already been visited, optimizing both space and time.


:[[3.41]]. You are given a search string and a magazine. You seek to generate all the characters in the search string by cutting them out from the magazine. Give an algorithm to efficiently determine whether the magazine contains all the letters in the search string.
[[3.41|Solution]]


:3.42. Reverse the words in a sentence—that is, “My name is Chris” becomes “Chris is name My.” Optimize for time and space.


:[[3.43]]. Determine whether a linked list contains a loop as quickly as possible without using any extra storage. Also, identify the location of the loop.
[[3.43|Solution]]


:3.44. You have an unordered array &lt;math&gt;X&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers. Find the array &lt;math&gt;M&lt;/math&gt; containing &lt;math&gt;n&lt;/math&gt; elements where &lt;math&gt;M_i&lt;/math&gt; is the product of all integers in &lt;math&gt;X&lt;/math&gt; except for &lt;math&gt;X_i&lt;/math&gt;. You may not use division. You can use extra memory. (Hint: there are solutions faster than &lt;math&gt;O(n^2)&lt;/math&gt;.)


:[[3.45]]. Give an algorithm for finding an ordered word pair (e.g. “New York”) occurring with the greatest frequency in a given webpage. Which data structures would you use? Optimize both time and space.
[[3.45|Solution]]


Back to [[Chapter List]]</text>
      <sha1>swxirqmr75pvnqocwlsbmj9rz5inslu</sha1>
    </revision>
    <revision>
      <id>262</id>
      <parentid>261</parentid>
      <timestamp>2020-09-18T15:10:36Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Applications of Tree Structures */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="16105">=Data Structure=

===Stacks, Queues, and Lists===

:[[3.1]]. A common problem for compilers and text editors is determining whether the parentheses in a string are balanced and properly nested. For example, the string &lt;math&gt;((())())()&lt;/math&gt; contains properly nested pairs of parentheses, which the strings &lt;math&gt;)()(&lt;/math&gt; and &lt;math&gt;())&lt;/math&gt; do not. Give an algorithm that returns true if a string contains properly nested and balanced parentheses, and false if otherwise. For full credit, identify the position of the first offending parenthesis if the string is not properly nested and balanced.
[[3.1|Solution]]


:3.2. Give an algorithm that takes a string &lt;math&gt;S&lt;/math&gt; consisting of opening and closing parentheses, say )()(())()()))())))(, and finds the length of the longest balanced parentheses in &lt;math&gt;S&lt;/math&gt;, which is 12 in the example above. (Hint: The solution is not necessarily a contiguous run of parenthesis from &lt;math&gt;S&lt;/math&gt;.)
 

:[[3.3]]. Give an algorithm to reverse the direction of a given singly linked list. In other words, after the reversal all pointers should now point backwards. Your algorithm should take linear time.
[[3.3|Solution]]


:3.4. Design a stack &lt;math&gt;S&lt;/math&gt; that supports ''S.push(x)'', ''S.pop()'', and ''S.findmin()'', which returns the minimum element of &lt;math&gt;S&lt;/math&gt;. All operations should run in constant time.


:[[3.5]]. We have seen how dynamic arrays enable arrays to grow while still achieving constant-time amortized performance. This problem concerns extending dynamic arrays to let them both grow and shrink on demand.
:(a) Consider an underflow strategy that cuts the array size in half whenever the array falls below half full. Give an example sequence of insertions and deletions where this strategy gives a bad amortized cost.
:(b) Then, give a better underflow strategy than that suggested above, one that achieves constant amortized cost per deletion.
[[3.5|Solution]]


:3.6. Suppose you seek to maintain the contents of a refrigerator so as to minimize food spoilage. What data structure should you use, and how should you use it?


:[[3.7]]. Work out the details of supporting constant-time deletion from a singly linked list as per the footnote from page 79, ideally to an actual implementation. Support the other operations as efficiently as possible. 
[[3.7|Solution]]

===Elementary Data Structures===

:3.8. Tic-tac-toe is a game played on an &lt;math&gt;n * n&lt;/math&gt; board (typically &lt;math&gt;n = 3&lt;/math&gt;) where two players take consecutive turns placing “O” and “X” marks onto the board cells. The game is won if n consecutive “O” or ‘X” marks are placed in a row, column, or diagonal. Create a data structure with &lt;math&gt;O(n)&lt;/math&gt; space that accepts a sequence of moves, and reports in constant time whether the last move won the game.


:[[3.9]]. Write a function which, given a sequence of digits 2–9 and a dictionary of &lt;math&gt;n&lt;/math&gt; words, reports all words described by this sequence when typed in on a standard telephone keypad. For the sequence 269 you should return any, box, boy, and cow, among other words.
[[3.9|Solution]]


:3.10. Two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; are anagrams if the letters of &lt;math&gt;X&lt;/math&gt; can be rearranged to form &lt;math&gt;Y&lt;/math&gt; . For example, silent/listen, and incest/insect are anagrams. Give an efficient algorithm to determine whether strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; are anagrams.

===Trees and Other Dictionary Structures===

:[[3.11]]. Design a dictionary data structure in which search, insertion, and deletion can all be processed in &lt;math&gt;O(1)&lt;/math&gt; time in the worst case. You may assume the set elements are integers drawn from a finite set &lt;math&gt;1, 2, .., n&lt;/math&gt;, and initialization can take &lt;math&gt;O(n)&lt;/math&gt; time.
[[3.11|Solution]]


:3.12. The maximum depth of a binary tree is the number of nodes on the path from the root down to the most distant leaf node. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm to find the maximum depth of a binary tree with &lt;math&gt;n&lt;/math&gt; nodes.


:[[3.13]]. Two elements of a binary search tree have been swapped by mistake. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm to identify these two elements so they can be swapped back.
[[3.13|Solution]]


:3.14. Given two binary search trees, merge them into a doubly linked list in sorted order.


:[[3.15]]. Describe an &lt;math&gt;O(n)&lt;/math&gt;-time algorithm that takes an &lt;math&gt;n&lt;/math&gt;-node binary search tree and constructs an equivalent height-balanced binary search tree. In a height-balanced binary search tree, the difference between the height of the left and right subtrees of every node is never more than 1.
[[3.15|Solution]]


:3.16. Find the storage efficiency ratio (the ratio of data space over total space) for each of the following binary tree implementations on n nodes:
:(a) All nodes store data, two child pointers, and a parent pointer. The data field requires 4 bytes and each pointer requires 4 bytes.
:(b) Only leaf nodes store data; internal nodes store two child pointers. The data field requires four bytes and each pointer requires two bytes.


:[[3.17]]. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm that determines whether a given &lt;math&gt;n&lt;/math&gt;-node binary tree is height-balanced (see Problem 3-15).
[[3.17|Solution]]


:3.18. Describe how to modify any balanced tree data structure such that search, insert, delete, minimum, and maximum still take &lt;math&gt;O(log n)&lt;/math&gt; time each, but successor and predecessor now take &lt;math&gt;O(1)&lt;/math&gt; time each. Which operations have to be modified to support this?


:[[3.19]]. Suppose you have access to a balanced dictionary data structure that supports each of the operations search, insert, delete, minimum, maximum, successor, and predecessor in &lt;math&gt;O(log n)&lt;/math&gt; time. Explain how to modify the insert and delete operations so they still take &lt;math&gt;O(log n)&lt;/math&gt; but now minimum and maximum take &lt;math&gt;O(1)&lt;/math&gt; time. (Hint: think in terms of using the abstract dictionary operations, instead of mucking about with pointers and the like.)
[[3.19|Solution]]


:3.20. Design a data structure to support the following operations:
:• ''insert''(&lt;math&gt;x,T&lt;/math&gt;) – Insert item &lt;math&gt;x&lt;/math&gt; into the set &lt;math&gt;T&lt;/math&gt;.
:• ''delete''(&lt;math&gt;k,T&lt;/math&gt;) – Delete the &lt;math&gt;k&lt;/math&gt;th smallest element from &lt;math&gt;T&lt;/math&gt;.
:• ''member''(&lt;math&gt;x,T&lt;/math&gt;) – Return true iff &lt;math&gt;x \in T&lt;/math&gt;.
:All operations must take &lt;math&gt;O(log n)&lt;/math&gt; time on an &lt;math&gt;n&lt;/math&gt;-element set.


:[[3.21]]. A ''concatenate operation'' takes two sets &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt;, where every key in &lt;math&gt;S_1&lt;/math&gt; is smaller than any key in &lt;math&gt;S_2&lt;/math&gt;, and merges them. Give an algorithm to concatenate two binary search trees into one binary search tree. The worst-case running time should be &lt;math&gt;O(h)&lt;/math&gt;, where &lt;math&gt;h&lt;/math&gt; is the maximal height of the two trees.
[[3.21|Solution]]

===Applications of Tree Structures===

:3.22. Design a data structure that supports the following two operations:
:• ''insert''(&lt;math&gt;x&lt;/math&gt;) – Insert item &lt;math&gt;x&lt;/math&gt; from the data stream to the data structure.
:• ''median''() – Return the median of all elements so far.
:All operations must take &lt;math&gt;O(log n)&lt;/math&gt; time on an &lt;math&gt;n&lt;/math&gt;-element set.


:[[3.23]]. Assume we are given a standard dictionary (balanced binary search tree) defined on a set of &lt;math&gt;n&lt;/math&gt; strings, each of length at most &lt;math&gt;l&lt;/math&gt;. We seek to print out all strings beginning with a particular prefix &lt;math&gt;p&lt;/math&gt;. Show how to do this in &lt;math&gt;O(ml log n)&lt;/math&gt; time, where &lt;math&gt;m&lt;/math&gt; is the number of strings.
[[3.23|Solution]]


:3.24. An array &lt;math&gt;A&lt;/math&gt; is called &lt;math&gt;k&lt;/math&gt;-unique if it does not contain a pair of duplicate elements within &lt;math&gt;k&lt;/math&gt; positions of each other, that is, there is no &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; such that &lt;math&gt;A[i] = A[j]&lt;/math&gt; and &lt;math&gt;|j - i| \leq k&lt;/math&gt;. Design a worst-case &lt;math&gt;O(n log k)&lt;/math&gt; algorithm to test if &lt;math&gt;A&lt;/math&gt; is &lt;math&gt;k&lt;/math&gt;-unique.


:[[3.25]]. In the ''bin-packing problem'', we are given &lt;math&gt;n&lt;/math&gt; objects, each weighing at most 1 kilogram. Our goal is to find the smallest number of bins that will hold the &lt;math&gt;n&lt;/math&gt; objects, with each bin holding 1 kilogram at most.
:• The ''best-fit heuristic'' for bin packing is as follows. Consider the objects in the order in which they are given. For each object, place it into the partially filled bin with the smallest amount of extra room after the object is inserted. If no such bin exists, start a new bin. Design an algorithm that implements the best-fit heuristic (taking as input the &lt;math&gt;n&lt;/math&gt; weights &lt;math&gt;w_1, w_2, ..., w_n&lt;/math&gt; and outputting the number of bins used) in &lt;math&gt;O(n log n)&lt;/math&gt; time.
:• Repeat the above using the ''worst-fit heuristic'', where we put the next object into the partially filled bin with the largest amount of extra room after the object is inserted.
[[3.25|Solution]]


:3.26. Suppose that we are given a sequence of &lt;math&gt;n&lt;/math&gt; values &lt;math&gt;x_1, x_2, ..., x_n&lt;/math&gt; and seek to quickly answer repeated queries of the form: given &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt;, find the smallest value in &lt;math&gt;x_i, . . . , x_j&lt;/math&gt;.
:(a) Design a data structure that uses &lt;math&gt;O(n^2)&lt;/math&gt; space and answers queries in &lt;math&gt;O(1)&lt;/math&gt; time.
:(b) Design a data structure that uses &lt;math&gt;O(n)&lt;/math&gt; space and answers queries in &lt;math&gt;O(log n)&lt;/math&gt; time. For partial credit, your data structure can use &lt;math&gt;O(n log n)&lt;/math&gt; space and have &lt;math&gt;O(log n)&lt;/math&gt; query time.


:[[3.27]]. Suppose you are given an input set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, and a black box that if given any sequence of integers and an integer &lt;math&gt;k&lt;/math&gt; instantly and correctly answers whether there is a subset of the input sequence whose sum is exactly &lt;math&gt;k&lt;/math&gt;. Show how to use the black box &lt;math&gt;O(n)&lt;/math&gt; times to find a subset of &lt;math&gt;S&lt;/math&gt; that adds up to &lt;math&gt;k&lt;/math&gt;.
[[3.27|Solution]]


:3.28. Let &lt;math&gt;A[1..n]&lt;/math&gt; be an array of real numbers. Design an algorithm to perform any sequence of the following operations:
:• ''Add''(&lt;math&gt;i,y&lt;/math&gt;) – Add the value &lt;math&gt;y&lt;/math&gt; to the &lt;math&gt;i&lt;/math&gt;th number.
:• ''Partial-sum''(&lt;math&gt;i&lt;/math&gt;) – Return the sum of the first &lt;math&gt;i&lt;/math&gt; numbers, that is, &lt;math&gt;\sum_{j=1}^i A[j]&lt;/math&gt;.
:There are no insertions or deletions; the only change is to the values of the numbers. Each operation should take &lt;math&gt;O(log n)&lt;/math&gt; steps. You may use one additional array of size &lt;math&gt;n&lt;/math&gt; as a work space.


:[[3.29]]. Extend the data structure of the previous problem to support insertions and deletions. Each element now has both a ''key'' and a ''value''. An element is accessed by its key, but the addition operation is applied to the values. The ''Partial_sum'' operation is different.
:• ''Add''(&lt;math&gt;k,y&lt;/math&gt;) – Add the value &lt;math&gt;y&lt;/math&gt; to the item with key &lt;math&gt;k&lt;/math&gt;.
:• ''Insert''(&lt;math&gt;k,y&lt;/math&gt;) – Insert a new item with key &lt;math&gt;k&lt;/math&gt; and value &lt;math&gt;y&lt;/math&gt;.
:• ''Delete''(&lt;math&gt;k&lt;/math&gt;) – Delete the item with key &lt;math&gt;k&lt;/math&gt;.
:• ''Partial-sum''(&lt;math&gt;k&lt;/math&gt;) – Return the sum of all the elements currently in the set whose key is less than &lt;math&gt;k&lt;/math&gt;, that is, &lt;math&gt;\sum_{i &lt; k} x_i&lt;/math&gt;. 
:The worst-case running time should still be &lt;math&gt;O(n log n)&lt;/math&gt; for any sequence of &lt;math&gt;O(n)&lt;/math&gt; operations.
[[3.29|Solution]]


:3.30. You are consulting for a hotel that has &lt;math&gt;n&lt;/math&gt; one-bed rooms. When a guest checks in, they ask for a room whose number is in the range &lt;math&gt;[l, h]&lt;/math&gt;. Propose a data structure that supports the following data operations in the allotted time:
:(a) ''Initialize''(&lt;math&gt;n&lt;/math&gt;): Initialize the data structure for empty rooms numbered &lt;math&gt;1, 2, . . . , n&lt;/math&gt;, in polynomial time.
:(b) ''Count''(&lt;math&gt;l, h&lt;/math&gt;): Return the number of available rooms in &lt;math&gt;[l, h]&lt;/math&gt;, in &lt;math&gt;O(log n)&lt;/math&gt; time.
:(c) ''Checkin''(&lt;math&gt;l, h&lt;/math&gt;): In &lt;math&gt;O(log n)&lt;/math&gt; time, return the first empty room in &lt;math&gt;[l, h]&lt;/math&gt; and mark it occupied, or return NIL if all the rooms in &lt;math&gt;[l, h]&lt;/math&gt; are occupied.
:(d) ''Checkout''(&lt;math&gt;x&lt;/math&gt;): Mark room &lt;math&gt;x&lt;/math&gt; as unoccupied, in &lt;math&gt;O(log n)&lt;/math&gt; time.


:[[3.31]]. Design a data structure that allows one to search, insert, and delete an integer &lt;math&gt;X&lt;/math&gt; in &lt;math&gt;O(1)&lt;/math&gt; time (i.e., constant time, independent of the total number of integers stored). Assume that &lt;math&gt;1 \leq X \leq n&lt;/math&gt; and that there are &lt;math&gt;m + n&lt;/math&gt; units of space available, where &lt;math&gt;m&lt;/math&gt; is the maximum number of integers that can be in the table at any one time. (Hint: use two arrays &lt;math&gt;A[1..n]&lt;/math&gt; and &lt;math&gt;B[1..m]&lt;/math&gt;.) You are not allowed to initialize either &lt;math&gt;A&lt;/math&gt; or &lt;math&gt;B&lt;/math&gt;, as that would take &lt;math&gt;O(m)&lt;/math&gt; or &lt;math&gt;O(n)&lt;/math&gt; operations. This means the arrays are full of random garbage to begin with, so you must be very careful.
[[3.31|Solution]]

===Implementation Projects===

:3.32. Implement versions of several different dictionary data structures, such as linked lists, binary trees, balanced binary search trees, and hash tables. Conduct experiments to assess the relative performance of these data structures in a simple application that reads a large text file and reports exactly one instance of each word that appears within it. This application can be efficiently implemented by maintaining a dictionary of all distinct words that have appeared thus far in the text and inserting/reporting each new word that appears in the stream. Write a brief report with your conclusions.


:[[3.33]]. A Caesar shift (see Section 21.6 (page 697)) is a very simple class of ciphers for secret messages. Unfortunately, they can be broken using statistical properties of English. Develop a program capable of decrypting Caesar shifts of sufficiently long texts.
[[3.33|Solution]]

===Interview Problems===

:3.34. What method would you use to look up a word in a dictionary?


:[[3.35]]. Imagine you have a closet full of shirts. What can you do to organize your shirts for easy retrieval?
[[3.35|Solution]]


:3.36. Write a function to find the middle node of a singly linked list.


:[[3.37]]. [4] Write a function to determine whether two binary trees are identical. Identical trees have the same key value at each position and the same structure.
[[3.37|Solution]]


:3.38. Write a program to convert a binary search tree into a linked list.


:[[3.39]]. Implement an algorithm to reverse a linked list. Now do it without recursion.
[[3.39|Solution]]


:3.40. What is the best data structure for maintaining URLs that have been visited by a web crawler? Give an algorithm to test whether a given URL has already been visited, optimizing both space and time.


:[[3.41]]. You are given a search string and a magazine. You seek to generate all the characters in the search string by cutting them out from the magazine. Give an algorithm to efficiently determine whether the magazine contains all the letters in the search string.
[[3.41|Solution]]


:3.42. Reverse the words in a sentence—that is, “My name is Chris” becomes “Chris is name My.” Optimize for time and space.


:[[3.43]]. Determine whether a linked list contains a loop as quickly as possible without using any extra storage. Also, identify the location of the loop.
[[3.43|Solution]]


:3.44. You have an unordered array &lt;math&gt;X&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers. Find the array &lt;math&gt;M&lt;/math&gt; containing &lt;math&gt;n&lt;/math&gt; elements where &lt;math&gt;M_i&lt;/math&gt; is the product of all integers in &lt;math&gt;X&lt;/math&gt; except for &lt;math&gt;X_i&lt;/math&gt;. You may not use division. You can use extra memory. (Hint: there are solutions faster than &lt;math&gt;O(n^2)&lt;/math&gt;.)


:[[3.45]]. Give an algorithm for finding an ordered word pair (e.g. “New York”) occurring with the greatest frequency in a given webpage. Which data structures would you use? Optimize both time and space.
[[3.45|Solution]]


Back to [[Chapter List]]</text>
      <sha1>cgzp4ao3c89gd1fgw13gof2533uxbgk</sha1>
    </revision>
    <revision>
      <id>297</id>
      <parentid>262</parentid>
      <timestamp>2020-09-20T18:11:43Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Interview Problems */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="16101">=Data Structure=

===Stacks, Queues, and Lists===

:[[3.1]]. A common problem for compilers and text editors is determining whether the parentheses in a string are balanced and properly nested. For example, the string &lt;math&gt;((())())()&lt;/math&gt; contains properly nested pairs of parentheses, which the strings &lt;math&gt;)()(&lt;/math&gt; and &lt;math&gt;())&lt;/math&gt; do not. Give an algorithm that returns true if a string contains properly nested and balanced parentheses, and false if otherwise. For full credit, identify the position of the first offending parenthesis if the string is not properly nested and balanced.
[[3.1|Solution]]


:3.2. Give an algorithm that takes a string &lt;math&gt;S&lt;/math&gt; consisting of opening and closing parentheses, say )()(())()()))())))(, and finds the length of the longest balanced parentheses in &lt;math&gt;S&lt;/math&gt;, which is 12 in the example above. (Hint: The solution is not necessarily a contiguous run of parenthesis from &lt;math&gt;S&lt;/math&gt;.)
 

:[[3.3]]. Give an algorithm to reverse the direction of a given singly linked list. In other words, after the reversal all pointers should now point backwards. Your algorithm should take linear time.
[[3.3|Solution]]


:3.4. Design a stack &lt;math&gt;S&lt;/math&gt; that supports ''S.push(x)'', ''S.pop()'', and ''S.findmin()'', which returns the minimum element of &lt;math&gt;S&lt;/math&gt;. All operations should run in constant time.


:[[3.5]]. We have seen how dynamic arrays enable arrays to grow while still achieving constant-time amortized performance. This problem concerns extending dynamic arrays to let them both grow and shrink on demand.
:(a) Consider an underflow strategy that cuts the array size in half whenever the array falls below half full. Give an example sequence of insertions and deletions where this strategy gives a bad amortized cost.
:(b) Then, give a better underflow strategy than that suggested above, one that achieves constant amortized cost per deletion.
[[3.5|Solution]]


:3.6. Suppose you seek to maintain the contents of a refrigerator so as to minimize food spoilage. What data structure should you use, and how should you use it?


:[[3.7]]. Work out the details of supporting constant-time deletion from a singly linked list as per the footnote from page 79, ideally to an actual implementation. Support the other operations as efficiently as possible. 
[[3.7|Solution]]

===Elementary Data Structures===

:3.8. Tic-tac-toe is a game played on an &lt;math&gt;n * n&lt;/math&gt; board (typically &lt;math&gt;n = 3&lt;/math&gt;) where two players take consecutive turns placing “O” and “X” marks onto the board cells. The game is won if n consecutive “O” or ‘X” marks are placed in a row, column, or diagonal. Create a data structure with &lt;math&gt;O(n)&lt;/math&gt; space that accepts a sequence of moves, and reports in constant time whether the last move won the game.


:[[3.9]]. Write a function which, given a sequence of digits 2–9 and a dictionary of &lt;math&gt;n&lt;/math&gt; words, reports all words described by this sequence when typed in on a standard telephone keypad. For the sequence 269 you should return any, box, boy, and cow, among other words.
[[3.9|Solution]]


:3.10. Two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; are anagrams if the letters of &lt;math&gt;X&lt;/math&gt; can be rearranged to form &lt;math&gt;Y&lt;/math&gt; . For example, silent/listen, and incest/insect are anagrams. Give an efficient algorithm to determine whether strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; are anagrams.

===Trees and Other Dictionary Structures===

:[[3.11]]. Design a dictionary data structure in which search, insertion, and deletion can all be processed in &lt;math&gt;O(1)&lt;/math&gt; time in the worst case. You may assume the set elements are integers drawn from a finite set &lt;math&gt;1, 2, .., n&lt;/math&gt;, and initialization can take &lt;math&gt;O(n)&lt;/math&gt; time.
[[3.11|Solution]]


:3.12. The maximum depth of a binary tree is the number of nodes on the path from the root down to the most distant leaf node. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm to find the maximum depth of a binary tree with &lt;math&gt;n&lt;/math&gt; nodes.


:[[3.13]]. Two elements of a binary search tree have been swapped by mistake. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm to identify these two elements so they can be swapped back.
[[3.13|Solution]]


:3.14. Given two binary search trees, merge them into a doubly linked list in sorted order.


:[[3.15]]. Describe an &lt;math&gt;O(n)&lt;/math&gt;-time algorithm that takes an &lt;math&gt;n&lt;/math&gt;-node binary search tree and constructs an equivalent height-balanced binary search tree. In a height-balanced binary search tree, the difference between the height of the left and right subtrees of every node is never more than 1.
[[3.15|Solution]]


:3.16. Find the storage efficiency ratio (the ratio of data space over total space) for each of the following binary tree implementations on n nodes:
:(a) All nodes store data, two child pointers, and a parent pointer. The data field requires 4 bytes and each pointer requires 4 bytes.
:(b) Only leaf nodes store data; internal nodes store two child pointers. The data field requires four bytes and each pointer requires two bytes.


:[[3.17]]. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm that determines whether a given &lt;math&gt;n&lt;/math&gt;-node binary tree is height-balanced (see Problem 3-15).
[[3.17|Solution]]


:3.18. Describe how to modify any balanced tree data structure such that search, insert, delete, minimum, and maximum still take &lt;math&gt;O(log n)&lt;/math&gt; time each, but successor and predecessor now take &lt;math&gt;O(1)&lt;/math&gt; time each. Which operations have to be modified to support this?


:[[3.19]]. Suppose you have access to a balanced dictionary data structure that supports each of the operations search, insert, delete, minimum, maximum, successor, and predecessor in &lt;math&gt;O(log n)&lt;/math&gt; time. Explain how to modify the insert and delete operations so they still take &lt;math&gt;O(log n)&lt;/math&gt; but now minimum and maximum take &lt;math&gt;O(1)&lt;/math&gt; time. (Hint: think in terms of using the abstract dictionary operations, instead of mucking about with pointers and the like.)
[[3.19|Solution]]


:3.20. Design a data structure to support the following operations:
:• ''insert''(&lt;math&gt;x,T&lt;/math&gt;) – Insert item &lt;math&gt;x&lt;/math&gt; into the set &lt;math&gt;T&lt;/math&gt;.
:• ''delete''(&lt;math&gt;k,T&lt;/math&gt;) – Delete the &lt;math&gt;k&lt;/math&gt;th smallest element from &lt;math&gt;T&lt;/math&gt;.
:• ''member''(&lt;math&gt;x,T&lt;/math&gt;) – Return true iff &lt;math&gt;x \in T&lt;/math&gt;.
:All operations must take &lt;math&gt;O(log n)&lt;/math&gt; time on an &lt;math&gt;n&lt;/math&gt;-element set.


:[[3.21]]. A ''concatenate operation'' takes two sets &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt;, where every key in &lt;math&gt;S_1&lt;/math&gt; is smaller than any key in &lt;math&gt;S_2&lt;/math&gt;, and merges them. Give an algorithm to concatenate two binary search trees into one binary search tree. The worst-case running time should be &lt;math&gt;O(h)&lt;/math&gt;, where &lt;math&gt;h&lt;/math&gt; is the maximal height of the two trees.
[[3.21|Solution]]

===Applications of Tree Structures===

:3.22. Design a data structure that supports the following two operations:
:• ''insert''(&lt;math&gt;x&lt;/math&gt;) – Insert item &lt;math&gt;x&lt;/math&gt; from the data stream to the data structure.
:• ''median''() – Return the median of all elements so far.
:All operations must take &lt;math&gt;O(log n)&lt;/math&gt; time on an &lt;math&gt;n&lt;/math&gt;-element set.


:[[3.23]]. Assume we are given a standard dictionary (balanced binary search tree) defined on a set of &lt;math&gt;n&lt;/math&gt; strings, each of length at most &lt;math&gt;l&lt;/math&gt;. We seek to print out all strings beginning with a particular prefix &lt;math&gt;p&lt;/math&gt;. Show how to do this in &lt;math&gt;O(ml log n)&lt;/math&gt; time, where &lt;math&gt;m&lt;/math&gt; is the number of strings.
[[3.23|Solution]]


:3.24. An array &lt;math&gt;A&lt;/math&gt; is called &lt;math&gt;k&lt;/math&gt;-unique if it does not contain a pair of duplicate elements within &lt;math&gt;k&lt;/math&gt; positions of each other, that is, there is no &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; such that &lt;math&gt;A[i] = A[j]&lt;/math&gt; and &lt;math&gt;|j - i| \leq k&lt;/math&gt;. Design a worst-case &lt;math&gt;O(n log k)&lt;/math&gt; algorithm to test if &lt;math&gt;A&lt;/math&gt; is &lt;math&gt;k&lt;/math&gt;-unique.


:[[3.25]]. In the ''bin-packing problem'', we are given &lt;math&gt;n&lt;/math&gt; objects, each weighing at most 1 kilogram. Our goal is to find the smallest number of bins that will hold the &lt;math&gt;n&lt;/math&gt; objects, with each bin holding 1 kilogram at most.
:• The ''best-fit heuristic'' for bin packing is as follows. Consider the objects in the order in which they are given. For each object, place it into the partially filled bin with the smallest amount of extra room after the object is inserted. If no such bin exists, start a new bin. Design an algorithm that implements the best-fit heuristic (taking as input the &lt;math&gt;n&lt;/math&gt; weights &lt;math&gt;w_1, w_2, ..., w_n&lt;/math&gt; and outputting the number of bins used) in &lt;math&gt;O(n log n)&lt;/math&gt; time.
:• Repeat the above using the ''worst-fit heuristic'', where we put the next object into the partially filled bin with the largest amount of extra room after the object is inserted.
[[3.25|Solution]]


:3.26. Suppose that we are given a sequence of &lt;math&gt;n&lt;/math&gt; values &lt;math&gt;x_1, x_2, ..., x_n&lt;/math&gt; and seek to quickly answer repeated queries of the form: given &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt;, find the smallest value in &lt;math&gt;x_i, . . . , x_j&lt;/math&gt;.
:(a) Design a data structure that uses &lt;math&gt;O(n^2)&lt;/math&gt; space and answers queries in &lt;math&gt;O(1)&lt;/math&gt; time.
:(b) Design a data structure that uses &lt;math&gt;O(n)&lt;/math&gt; space and answers queries in &lt;math&gt;O(log n)&lt;/math&gt; time. For partial credit, your data structure can use &lt;math&gt;O(n log n)&lt;/math&gt; space and have &lt;math&gt;O(log n)&lt;/math&gt; query time.


:[[3.27]]. Suppose you are given an input set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, and a black box that if given any sequence of integers and an integer &lt;math&gt;k&lt;/math&gt; instantly and correctly answers whether there is a subset of the input sequence whose sum is exactly &lt;math&gt;k&lt;/math&gt;. Show how to use the black box &lt;math&gt;O(n)&lt;/math&gt; times to find a subset of &lt;math&gt;S&lt;/math&gt; that adds up to &lt;math&gt;k&lt;/math&gt;.
[[3.27|Solution]]


:3.28. Let &lt;math&gt;A[1..n]&lt;/math&gt; be an array of real numbers. Design an algorithm to perform any sequence of the following operations:
:• ''Add''(&lt;math&gt;i,y&lt;/math&gt;) – Add the value &lt;math&gt;y&lt;/math&gt; to the &lt;math&gt;i&lt;/math&gt;th number.
:• ''Partial-sum''(&lt;math&gt;i&lt;/math&gt;) – Return the sum of the first &lt;math&gt;i&lt;/math&gt; numbers, that is, &lt;math&gt;\sum_{j=1}^i A[j]&lt;/math&gt;.
:There are no insertions or deletions; the only change is to the values of the numbers. Each operation should take &lt;math&gt;O(log n)&lt;/math&gt; steps. You may use one additional array of size &lt;math&gt;n&lt;/math&gt; as a work space.


:[[3.29]]. Extend the data structure of the previous problem to support insertions and deletions. Each element now has both a ''key'' and a ''value''. An element is accessed by its key, but the addition operation is applied to the values. The ''Partial_sum'' operation is different.
:• ''Add''(&lt;math&gt;k,y&lt;/math&gt;) – Add the value &lt;math&gt;y&lt;/math&gt; to the item with key &lt;math&gt;k&lt;/math&gt;.
:• ''Insert''(&lt;math&gt;k,y&lt;/math&gt;) – Insert a new item with key &lt;math&gt;k&lt;/math&gt; and value &lt;math&gt;y&lt;/math&gt;.
:• ''Delete''(&lt;math&gt;k&lt;/math&gt;) – Delete the item with key &lt;math&gt;k&lt;/math&gt;.
:• ''Partial-sum''(&lt;math&gt;k&lt;/math&gt;) – Return the sum of all the elements currently in the set whose key is less than &lt;math&gt;k&lt;/math&gt;, that is, &lt;math&gt;\sum_{i &lt; k} x_i&lt;/math&gt;. 
:The worst-case running time should still be &lt;math&gt;O(n log n)&lt;/math&gt; for any sequence of &lt;math&gt;O(n)&lt;/math&gt; operations.
[[3.29|Solution]]


:3.30. You are consulting for a hotel that has &lt;math&gt;n&lt;/math&gt; one-bed rooms. When a guest checks in, they ask for a room whose number is in the range &lt;math&gt;[l, h]&lt;/math&gt;. Propose a data structure that supports the following data operations in the allotted time:
:(a) ''Initialize''(&lt;math&gt;n&lt;/math&gt;): Initialize the data structure for empty rooms numbered &lt;math&gt;1, 2, . . . , n&lt;/math&gt;, in polynomial time.
:(b) ''Count''(&lt;math&gt;l, h&lt;/math&gt;): Return the number of available rooms in &lt;math&gt;[l, h]&lt;/math&gt;, in &lt;math&gt;O(log n)&lt;/math&gt; time.
:(c) ''Checkin''(&lt;math&gt;l, h&lt;/math&gt;): In &lt;math&gt;O(log n)&lt;/math&gt; time, return the first empty room in &lt;math&gt;[l, h]&lt;/math&gt; and mark it occupied, or return NIL if all the rooms in &lt;math&gt;[l, h]&lt;/math&gt; are occupied.
:(d) ''Checkout''(&lt;math&gt;x&lt;/math&gt;): Mark room &lt;math&gt;x&lt;/math&gt; as unoccupied, in &lt;math&gt;O(log n)&lt;/math&gt; time.


:[[3.31]]. Design a data structure that allows one to search, insert, and delete an integer &lt;math&gt;X&lt;/math&gt; in &lt;math&gt;O(1)&lt;/math&gt; time (i.e., constant time, independent of the total number of integers stored). Assume that &lt;math&gt;1 \leq X \leq n&lt;/math&gt; and that there are &lt;math&gt;m + n&lt;/math&gt; units of space available, where &lt;math&gt;m&lt;/math&gt; is the maximum number of integers that can be in the table at any one time. (Hint: use two arrays &lt;math&gt;A[1..n]&lt;/math&gt; and &lt;math&gt;B[1..m]&lt;/math&gt;.) You are not allowed to initialize either &lt;math&gt;A&lt;/math&gt; or &lt;math&gt;B&lt;/math&gt;, as that would take &lt;math&gt;O(m)&lt;/math&gt; or &lt;math&gt;O(n)&lt;/math&gt; operations. This means the arrays are full of random garbage to begin with, so you must be very careful.
[[3.31|Solution]]

===Implementation Projects===

:3.32. Implement versions of several different dictionary data structures, such as linked lists, binary trees, balanced binary search trees, and hash tables. Conduct experiments to assess the relative performance of these data structures in a simple application that reads a large text file and reports exactly one instance of each word that appears within it. This application can be efficiently implemented by maintaining a dictionary of all distinct words that have appeared thus far in the text and inserting/reporting each new word that appears in the stream. Write a brief report with your conclusions.


:[[3.33]]. A Caesar shift (see Section 21.6 (page 697)) is a very simple class of ciphers for secret messages. Unfortunately, they can be broken using statistical properties of English. Develop a program capable of decrypting Caesar shifts of sufficiently long texts.
[[3.33|Solution]]

===Interview Problems===

:3.34. What method would you use to look up a word in a dictionary?


:[[3.35]]. Imagine you have a closet full of shirts. What can you do to organize your shirts for easy retrieval?
[[3.35|Solution]]


:3.36. Write a function to find the middle node of a singly linked list.


:[[3.37]]. Write a function to determine whether two binary trees are identical. Identical trees have the same key value at each position and the same structure.
[[3.37|Solution]]


:3.38. Write a program to convert a binary search tree into a linked list.


:[[3.39]]. Implement an algorithm to reverse a linked list. Now do it without recursion.
[[3.39|Solution]]


:3.40. What is the best data structure for maintaining URLs that have been visited by a web crawler? Give an algorithm to test whether a given URL has already been visited, optimizing both space and time.


:[[3.41]]. You are given a search string and a magazine. You seek to generate all the characters in the search string by cutting them out from the magazine. Give an algorithm to efficiently determine whether the magazine contains all the letters in the search string.
[[3.41|Solution]]


:3.42. Reverse the words in a sentence—that is, “My name is Chris” becomes “Chris is name My.” Optimize for time and space.


:[[3.43]]. Determine whether a linked list contains a loop as quickly as possible without using any extra storage. Also, identify the location of the loop.
[[3.43|Solution]]


:3.44. You have an unordered array &lt;math&gt;X&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers. Find the array &lt;math&gt;M&lt;/math&gt; containing &lt;math&gt;n&lt;/math&gt; elements where &lt;math&gt;M_i&lt;/math&gt; is the product of all integers in &lt;math&gt;X&lt;/math&gt; except for &lt;math&gt;X_i&lt;/math&gt;. You may not use division. You can use extra memory. (Hint: there are solutions faster than &lt;math&gt;O(n^2)&lt;/math&gt;.)


:[[3.45]]. Give an algorithm for finding an ordered word pair (e.g. “New York”) occurring with the greatest frequency in a given webpage. Which data structures would you use? Optimize both time and space.
[[3.45|Solution]]


Back to [[Chapter List]]</text>
      <sha1>skyoxfdzbe3471m1odk3k3qdn7f53lx</sha1>
    </revision>
    <revision>
      <id>438</id>
      <parentid>297</parentid>
      <timestamp>2020-09-28T17:37:22Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Data Structure */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="16102">=Data Structures=

===Stacks, Queues, and Lists===

:[[3.1]]. A common problem for compilers and text editors is determining whether the parentheses in a string are balanced and properly nested. For example, the string &lt;math&gt;((())())()&lt;/math&gt; contains properly nested pairs of parentheses, which the strings &lt;math&gt;)()(&lt;/math&gt; and &lt;math&gt;())&lt;/math&gt; do not. Give an algorithm that returns true if a string contains properly nested and balanced parentheses, and false if otherwise. For full credit, identify the position of the first offending parenthesis if the string is not properly nested and balanced.
[[3.1|Solution]]


:3.2. Give an algorithm that takes a string &lt;math&gt;S&lt;/math&gt; consisting of opening and closing parentheses, say )()(())()()))())))(, and finds the length of the longest balanced parentheses in &lt;math&gt;S&lt;/math&gt;, which is 12 in the example above. (Hint: The solution is not necessarily a contiguous run of parenthesis from &lt;math&gt;S&lt;/math&gt;.)
 

:[[3.3]]. Give an algorithm to reverse the direction of a given singly linked list. In other words, after the reversal all pointers should now point backwards. Your algorithm should take linear time.
[[3.3|Solution]]


:3.4. Design a stack &lt;math&gt;S&lt;/math&gt; that supports ''S.push(x)'', ''S.pop()'', and ''S.findmin()'', which returns the minimum element of &lt;math&gt;S&lt;/math&gt;. All operations should run in constant time.


:[[3.5]]. We have seen how dynamic arrays enable arrays to grow while still achieving constant-time amortized performance. This problem concerns extending dynamic arrays to let them both grow and shrink on demand.
:(a) Consider an underflow strategy that cuts the array size in half whenever the array falls below half full. Give an example sequence of insertions and deletions where this strategy gives a bad amortized cost.
:(b) Then, give a better underflow strategy than that suggested above, one that achieves constant amortized cost per deletion.
[[3.5|Solution]]


:3.6. Suppose you seek to maintain the contents of a refrigerator so as to minimize food spoilage. What data structure should you use, and how should you use it?


:[[3.7]]. Work out the details of supporting constant-time deletion from a singly linked list as per the footnote from page 79, ideally to an actual implementation. Support the other operations as efficiently as possible. 
[[3.7|Solution]]

===Elementary Data Structures===

:3.8. Tic-tac-toe is a game played on an &lt;math&gt;n * n&lt;/math&gt; board (typically &lt;math&gt;n = 3&lt;/math&gt;) where two players take consecutive turns placing “O” and “X” marks onto the board cells. The game is won if n consecutive “O” or ‘X” marks are placed in a row, column, or diagonal. Create a data structure with &lt;math&gt;O(n)&lt;/math&gt; space that accepts a sequence of moves, and reports in constant time whether the last move won the game.


:[[3.9]]. Write a function which, given a sequence of digits 2–9 and a dictionary of &lt;math&gt;n&lt;/math&gt; words, reports all words described by this sequence when typed in on a standard telephone keypad. For the sequence 269 you should return any, box, boy, and cow, among other words.
[[3.9|Solution]]


:3.10. Two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; are anagrams if the letters of &lt;math&gt;X&lt;/math&gt; can be rearranged to form &lt;math&gt;Y&lt;/math&gt; . For example, silent/listen, and incest/insect are anagrams. Give an efficient algorithm to determine whether strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; are anagrams.

===Trees and Other Dictionary Structures===

:[[3.11]]. Design a dictionary data structure in which search, insertion, and deletion can all be processed in &lt;math&gt;O(1)&lt;/math&gt; time in the worst case. You may assume the set elements are integers drawn from a finite set &lt;math&gt;1, 2, .., n&lt;/math&gt;, and initialization can take &lt;math&gt;O(n)&lt;/math&gt; time.
[[3.11|Solution]]


:3.12. The maximum depth of a binary tree is the number of nodes on the path from the root down to the most distant leaf node. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm to find the maximum depth of a binary tree with &lt;math&gt;n&lt;/math&gt; nodes.


:[[3.13]]. Two elements of a binary search tree have been swapped by mistake. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm to identify these two elements so they can be swapped back.
[[3.13|Solution]]


:3.14. Given two binary search trees, merge them into a doubly linked list in sorted order.


:[[3.15]]. Describe an &lt;math&gt;O(n)&lt;/math&gt;-time algorithm that takes an &lt;math&gt;n&lt;/math&gt;-node binary search tree and constructs an equivalent height-balanced binary search tree. In a height-balanced binary search tree, the difference between the height of the left and right subtrees of every node is never more than 1.
[[3.15|Solution]]


:3.16. Find the storage efficiency ratio (the ratio of data space over total space) for each of the following binary tree implementations on n nodes:
:(a) All nodes store data, two child pointers, and a parent pointer. The data field requires 4 bytes and each pointer requires 4 bytes.
:(b) Only leaf nodes store data; internal nodes store two child pointers. The data field requires four bytes and each pointer requires two bytes.


:[[3.17]]. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm that determines whether a given &lt;math&gt;n&lt;/math&gt;-node binary tree is height-balanced (see Problem 3-15).
[[3.17|Solution]]


:3.18. Describe how to modify any balanced tree data structure such that search, insert, delete, minimum, and maximum still take &lt;math&gt;O(log n)&lt;/math&gt; time each, but successor and predecessor now take &lt;math&gt;O(1)&lt;/math&gt; time each. Which operations have to be modified to support this?


:[[3.19]]. Suppose you have access to a balanced dictionary data structure that supports each of the operations search, insert, delete, minimum, maximum, successor, and predecessor in &lt;math&gt;O(log n)&lt;/math&gt; time. Explain how to modify the insert and delete operations so they still take &lt;math&gt;O(log n)&lt;/math&gt; but now minimum and maximum take &lt;math&gt;O(1)&lt;/math&gt; time. (Hint: think in terms of using the abstract dictionary operations, instead of mucking about with pointers and the like.)
[[3.19|Solution]]


:3.20. Design a data structure to support the following operations:
:• ''insert''(&lt;math&gt;x,T&lt;/math&gt;) – Insert item &lt;math&gt;x&lt;/math&gt; into the set &lt;math&gt;T&lt;/math&gt;.
:• ''delete''(&lt;math&gt;k,T&lt;/math&gt;) – Delete the &lt;math&gt;k&lt;/math&gt;th smallest element from &lt;math&gt;T&lt;/math&gt;.
:• ''member''(&lt;math&gt;x,T&lt;/math&gt;) – Return true iff &lt;math&gt;x \in T&lt;/math&gt;.
:All operations must take &lt;math&gt;O(log n)&lt;/math&gt; time on an &lt;math&gt;n&lt;/math&gt;-element set.


:[[3.21]]. A ''concatenate operation'' takes two sets &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt;, where every key in &lt;math&gt;S_1&lt;/math&gt; is smaller than any key in &lt;math&gt;S_2&lt;/math&gt;, and merges them. Give an algorithm to concatenate two binary search trees into one binary search tree. The worst-case running time should be &lt;math&gt;O(h)&lt;/math&gt;, where &lt;math&gt;h&lt;/math&gt; is the maximal height of the two trees.
[[3.21|Solution]]

===Applications of Tree Structures===

:3.22. Design a data structure that supports the following two operations:
:• ''insert''(&lt;math&gt;x&lt;/math&gt;) – Insert item &lt;math&gt;x&lt;/math&gt; from the data stream to the data structure.
:• ''median''() – Return the median of all elements so far.
:All operations must take &lt;math&gt;O(log n)&lt;/math&gt; time on an &lt;math&gt;n&lt;/math&gt;-element set.


:[[3.23]]. Assume we are given a standard dictionary (balanced binary search tree) defined on a set of &lt;math&gt;n&lt;/math&gt; strings, each of length at most &lt;math&gt;l&lt;/math&gt;. We seek to print out all strings beginning with a particular prefix &lt;math&gt;p&lt;/math&gt;. Show how to do this in &lt;math&gt;O(ml log n)&lt;/math&gt; time, where &lt;math&gt;m&lt;/math&gt; is the number of strings.
[[3.23|Solution]]


:3.24. An array &lt;math&gt;A&lt;/math&gt; is called &lt;math&gt;k&lt;/math&gt;-unique if it does not contain a pair of duplicate elements within &lt;math&gt;k&lt;/math&gt; positions of each other, that is, there is no &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; such that &lt;math&gt;A[i] = A[j]&lt;/math&gt; and &lt;math&gt;|j - i| \leq k&lt;/math&gt;. Design a worst-case &lt;math&gt;O(n log k)&lt;/math&gt; algorithm to test if &lt;math&gt;A&lt;/math&gt; is &lt;math&gt;k&lt;/math&gt;-unique.


:[[3.25]]. In the ''bin-packing problem'', we are given &lt;math&gt;n&lt;/math&gt; objects, each weighing at most 1 kilogram. Our goal is to find the smallest number of bins that will hold the &lt;math&gt;n&lt;/math&gt; objects, with each bin holding 1 kilogram at most.
:• The ''best-fit heuristic'' for bin packing is as follows. Consider the objects in the order in which they are given. For each object, place it into the partially filled bin with the smallest amount of extra room after the object is inserted. If no such bin exists, start a new bin. Design an algorithm that implements the best-fit heuristic (taking as input the &lt;math&gt;n&lt;/math&gt; weights &lt;math&gt;w_1, w_2, ..., w_n&lt;/math&gt; and outputting the number of bins used) in &lt;math&gt;O(n log n)&lt;/math&gt; time.
:• Repeat the above using the ''worst-fit heuristic'', where we put the next object into the partially filled bin with the largest amount of extra room after the object is inserted.
[[3.25|Solution]]


:3.26. Suppose that we are given a sequence of &lt;math&gt;n&lt;/math&gt; values &lt;math&gt;x_1, x_2, ..., x_n&lt;/math&gt; and seek to quickly answer repeated queries of the form: given &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt;, find the smallest value in &lt;math&gt;x_i, . . . , x_j&lt;/math&gt;.
:(a) Design a data structure that uses &lt;math&gt;O(n^2)&lt;/math&gt; space and answers queries in &lt;math&gt;O(1)&lt;/math&gt; time.
:(b) Design a data structure that uses &lt;math&gt;O(n)&lt;/math&gt; space and answers queries in &lt;math&gt;O(log n)&lt;/math&gt; time. For partial credit, your data structure can use &lt;math&gt;O(n log n)&lt;/math&gt; space and have &lt;math&gt;O(log n)&lt;/math&gt; query time.


:[[3.27]]. Suppose you are given an input set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, and a black box that if given any sequence of integers and an integer &lt;math&gt;k&lt;/math&gt; instantly and correctly answers whether there is a subset of the input sequence whose sum is exactly &lt;math&gt;k&lt;/math&gt;. Show how to use the black box &lt;math&gt;O(n)&lt;/math&gt; times to find a subset of &lt;math&gt;S&lt;/math&gt; that adds up to &lt;math&gt;k&lt;/math&gt;.
[[3.27|Solution]]


:3.28. Let &lt;math&gt;A[1..n]&lt;/math&gt; be an array of real numbers. Design an algorithm to perform any sequence of the following operations:
:• ''Add''(&lt;math&gt;i,y&lt;/math&gt;) – Add the value &lt;math&gt;y&lt;/math&gt; to the &lt;math&gt;i&lt;/math&gt;th number.
:• ''Partial-sum''(&lt;math&gt;i&lt;/math&gt;) – Return the sum of the first &lt;math&gt;i&lt;/math&gt; numbers, that is, &lt;math&gt;\sum_{j=1}^i A[j]&lt;/math&gt;.
:There are no insertions or deletions; the only change is to the values of the numbers. Each operation should take &lt;math&gt;O(log n)&lt;/math&gt; steps. You may use one additional array of size &lt;math&gt;n&lt;/math&gt; as a work space.


:[[3.29]]. Extend the data structure of the previous problem to support insertions and deletions. Each element now has both a ''key'' and a ''value''. An element is accessed by its key, but the addition operation is applied to the values. The ''Partial_sum'' operation is different.
:• ''Add''(&lt;math&gt;k,y&lt;/math&gt;) – Add the value &lt;math&gt;y&lt;/math&gt; to the item with key &lt;math&gt;k&lt;/math&gt;.
:• ''Insert''(&lt;math&gt;k,y&lt;/math&gt;) – Insert a new item with key &lt;math&gt;k&lt;/math&gt; and value &lt;math&gt;y&lt;/math&gt;.
:• ''Delete''(&lt;math&gt;k&lt;/math&gt;) – Delete the item with key &lt;math&gt;k&lt;/math&gt;.
:• ''Partial-sum''(&lt;math&gt;k&lt;/math&gt;) – Return the sum of all the elements currently in the set whose key is less than &lt;math&gt;k&lt;/math&gt;, that is, &lt;math&gt;\sum_{i &lt; k} x_i&lt;/math&gt;. 
:The worst-case running time should still be &lt;math&gt;O(n log n)&lt;/math&gt; for any sequence of &lt;math&gt;O(n)&lt;/math&gt; operations.
[[3.29|Solution]]


:3.30. You are consulting for a hotel that has &lt;math&gt;n&lt;/math&gt; one-bed rooms. When a guest checks in, they ask for a room whose number is in the range &lt;math&gt;[l, h]&lt;/math&gt;. Propose a data structure that supports the following data operations in the allotted time:
:(a) ''Initialize''(&lt;math&gt;n&lt;/math&gt;): Initialize the data structure for empty rooms numbered &lt;math&gt;1, 2, . . . , n&lt;/math&gt;, in polynomial time.
:(b) ''Count''(&lt;math&gt;l, h&lt;/math&gt;): Return the number of available rooms in &lt;math&gt;[l, h]&lt;/math&gt;, in &lt;math&gt;O(log n)&lt;/math&gt; time.
:(c) ''Checkin''(&lt;math&gt;l, h&lt;/math&gt;): In &lt;math&gt;O(log n)&lt;/math&gt; time, return the first empty room in &lt;math&gt;[l, h]&lt;/math&gt; and mark it occupied, or return NIL if all the rooms in &lt;math&gt;[l, h]&lt;/math&gt; are occupied.
:(d) ''Checkout''(&lt;math&gt;x&lt;/math&gt;): Mark room &lt;math&gt;x&lt;/math&gt; as unoccupied, in &lt;math&gt;O(log n)&lt;/math&gt; time.


:[[3.31]]. Design a data structure that allows one to search, insert, and delete an integer &lt;math&gt;X&lt;/math&gt; in &lt;math&gt;O(1)&lt;/math&gt; time (i.e., constant time, independent of the total number of integers stored). Assume that &lt;math&gt;1 \leq X \leq n&lt;/math&gt; and that there are &lt;math&gt;m + n&lt;/math&gt; units of space available, where &lt;math&gt;m&lt;/math&gt; is the maximum number of integers that can be in the table at any one time. (Hint: use two arrays &lt;math&gt;A[1..n]&lt;/math&gt; and &lt;math&gt;B[1..m]&lt;/math&gt;.) You are not allowed to initialize either &lt;math&gt;A&lt;/math&gt; or &lt;math&gt;B&lt;/math&gt;, as that would take &lt;math&gt;O(m)&lt;/math&gt; or &lt;math&gt;O(n)&lt;/math&gt; operations. This means the arrays are full of random garbage to begin with, so you must be very careful.
[[3.31|Solution]]

===Implementation Projects===

:3.32. Implement versions of several different dictionary data structures, such as linked lists, binary trees, balanced binary search trees, and hash tables. Conduct experiments to assess the relative performance of these data structures in a simple application that reads a large text file and reports exactly one instance of each word that appears within it. This application can be efficiently implemented by maintaining a dictionary of all distinct words that have appeared thus far in the text and inserting/reporting each new word that appears in the stream. Write a brief report with your conclusions.


:[[3.33]]. A Caesar shift (see Section 21.6 (page 697)) is a very simple class of ciphers for secret messages. Unfortunately, they can be broken using statistical properties of English. Develop a program capable of decrypting Caesar shifts of sufficiently long texts.
[[3.33|Solution]]

===Interview Problems===

:3.34. What method would you use to look up a word in a dictionary?


:[[3.35]]. Imagine you have a closet full of shirts. What can you do to organize your shirts for easy retrieval?
[[3.35|Solution]]


:3.36. Write a function to find the middle node of a singly linked list.


:[[3.37]]. Write a function to determine whether two binary trees are identical. Identical trees have the same key value at each position and the same structure.
[[3.37|Solution]]


:3.38. Write a program to convert a binary search tree into a linked list.


:[[3.39]]. Implement an algorithm to reverse a linked list. Now do it without recursion.
[[3.39|Solution]]


:3.40. What is the best data structure for maintaining URLs that have been visited by a web crawler? Give an algorithm to test whether a given URL has already been visited, optimizing both space and time.


:[[3.41]]. You are given a search string and a magazine. You seek to generate all the characters in the search string by cutting them out from the magazine. Give an algorithm to efficiently determine whether the magazine contains all the letters in the search string.
[[3.41|Solution]]


:3.42. Reverse the words in a sentence—that is, “My name is Chris” becomes “Chris is name My.” Optimize for time and space.


:[[3.43]]. Determine whether a linked list contains a loop as quickly as possible without using any extra storage. Also, identify the location of the loop.
[[3.43|Solution]]


:3.44. You have an unordered array &lt;math&gt;X&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers. Find the array &lt;math&gt;M&lt;/math&gt; containing &lt;math&gt;n&lt;/math&gt; elements where &lt;math&gt;M_i&lt;/math&gt; is the product of all integers in &lt;math&gt;X&lt;/math&gt; except for &lt;math&gt;X_i&lt;/math&gt;. You may not use division. You can use extra memory. (Hint: there are solutions faster than &lt;math&gt;O(n^2)&lt;/math&gt;.)


:[[3.45]]. Give an algorithm for finding an ordered word pair (e.g. “New York”) occurring with the greatest frequency in a given webpage. Which data structures would you use? Optimize both time and space.
[[3.45|Solution]]


Back to [[Chapter List]]</text>
      <sha1>km8qjoqkpiozsv7qqnzv7ogkbytq448</sha1>
    </revision>
    <revision>
      <id>448</id>
      <parentid>438</parentid>
      <timestamp>2020-10-01T18:06:35Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <minor/>
      <comment>Protected "[[Chapter 3]]" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="16102">=Data Structures=

===Stacks, Queues, and Lists===

:[[3.1]]. A common problem for compilers and text editors is determining whether the parentheses in a string are balanced and properly nested. For example, the string &lt;math&gt;((())())()&lt;/math&gt; contains properly nested pairs of parentheses, which the strings &lt;math&gt;)()(&lt;/math&gt; and &lt;math&gt;())&lt;/math&gt; do not. Give an algorithm that returns true if a string contains properly nested and balanced parentheses, and false if otherwise. For full credit, identify the position of the first offending parenthesis if the string is not properly nested and balanced.
[[3.1|Solution]]


:3.2. Give an algorithm that takes a string &lt;math&gt;S&lt;/math&gt; consisting of opening and closing parentheses, say )()(())()()))())))(, and finds the length of the longest balanced parentheses in &lt;math&gt;S&lt;/math&gt;, which is 12 in the example above. (Hint: The solution is not necessarily a contiguous run of parenthesis from &lt;math&gt;S&lt;/math&gt;.)
 

:[[3.3]]. Give an algorithm to reverse the direction of a given singly linked list. In other words, after the reversal all pointers should now point backwards. Your algorithm should take linear time.
[[3.3|Solution]]


:3.4. Design a stack &lt;math&gt;S&lt;/math&gt; that supports ''S.push(x)'', ''S.pop()'', and ''S.findmin()'', which returns the minimum element of &lt;math&gt;S&lt;/math&gt;. All operations should run in constant time.


:[[3.5]]. We have seen how dynamic arrays enable arrays to grow while still achieving constant-time amortized performance. This problem concerns extending dynamic arrays to let them both grow and shrink on demand.
:(a) Consider an underflow strategy that cuts the array size in half whenever the array falls below half full. Give an example sequence of insertions and deletions where this strategy gives a bad amortized cost.
:(b) Then, give a better underflow strategy than that suggested above, one that achieves constant amortized cost per deletion.
[[3.5|Solution]]


:3.6. Suppose you seek to maintain the contents of a refrigerator so as to minimize food spoilage. What data structure should you use, and how should you use it?


:[[3.7]]. Work out the details of supporting constant-time deletion from a singly linked list as per the footnote from page 79, ideally to an actual implementation. Support the other operations as efficiently as possible. 
[[3.7|Solution]]

===Elementary Data Structures===

:3.8. Tic-tac-toe is a game played on an &lt;math&gt;n * n&lt;/math&gt; board (typically &lt;math&gt;n = 3&lt;/math&gt;) where two players take consecutive turns placing “O” and “X” marks onto the board cells. The game is won if n consecutive “O” or ‘X” marks are placed in a row, column, or diagonal. Create a data structure with &lt;math&gt;O(n)&lt;/math&gt; space that accepts a sequence of moves, and reports in constant time whether the last move won the game.


:[[3.9]]. Write a function which, given a sequence of digits 2–9 and a dictionary of &lt;math&gt;n&lt;/math&gt; words, reports all words described by this sequence when typed in on a standard telephone keypad. For the sequence 269 you should return any, box, boy, and cow, among other words.
[[3.9|Solution]]


:3.10. Two strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; are anagrams if the letters of &lt;math&gt;X&lt;/math&gt; can be rearranged to form &lt;math&gt;Y&lt;/math&gt; . For example, silent/listen, and incest/insect are anagrams. Give an efficient algorithm to determine whether strings &lt;math&gt;X&lt;/math&gt; and &lt;math&gt;Y&lt;/math&gt; are anagrams.

===Trees and Other Dictionary Structures===

:[[3.11]]. Design a dictionary data structure in which search, insertion, and deletion can all be processed in &lt;math&gt;O(1)&lt;/math&gt; time in the worst case. You may assume the set elements are integers drawn from a finite set &lt;math&gt;1, 2, .., n&lt;/math&gt;, and initialization can take &lt;math&gt;O(n)&lt;/math&gt; time.
[[3.11|Solution]]


:3.12. The maximum depth of a binary tree is the number of nodes on the path from the root down to the most distant leaf node. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm to find the maximum depth of a binary tree with &lt;math&gt;n&lt;/math&gt; nodes.


:[[3.13]]. Two elements of a binary search tree have been swapped by mistake. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm to identify these two elements so they can be swapped back.
[[3.13|Solution]]


:3.14. Given two binary search trees, merge them into a doubly linked list in sorted order.


:[[3.15]]. Describe an &lt;math&gt;O(n)&lt;/math&gt;-time algorithm that takes an &lt;math&gt;n&lt;/math&gt;-node binary search tree and constructs an equivalent height-balanced binary search tree. In a height-balanced binary search tree, the difference between the height of the left and right subtrees of every node is never more than 1.
[[3.15|Solution]]


:3.16. Find the storage efficiency ratio (the ratio of data space over total space) for each of the following binary tree implementations on n nodes:
:(a) All nodes store data, two child pointers, and a parent pointer. The data field requires 4 bytes and each pointer requires 4 bytes.
:(b) Only leaf nodes store data; internal nodes store two child pointers. The data field requires four bytes and each pointer requires two bytes.


:[[3.17]]. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm that determines whether a given &lt;math&gt;n&lt;/math&gt;-node binary tree is height-balanced (see Problem 3-15).
[[3.17|Solution]]


:3.18. Describe how to modify any balanced tree data structure such that search, insert, delete, minimum, and maximum still take &lt;math&gt;O(log n)&lt;/math&gt; time each, but successor and predecessor now take &lt;math&gt;O(1)&lt;/math&gt; time each. Which operations have to be modified to support this?


:[[3.19]]. Suppose you have access to a balanced dictionary data structure that supports each of the operations search, insert, delete, minimum, maximum, successor, and predecessor in &lt;math&gt;O(log n)&lt;/math&gt; time. Explain how to modify the insert and delete operations so they still take &lt;math&gt;O(log n)&lt;/math&gt; but now minimum and maximum take &lt;math&gt;O(1)&lt;/math&gt; time. (Hint: think in terms of using the abstract dictionary operations, instead of mucking about with pointers and the like.)
[[3.19|Solution]]


:3.20. Design a data structure to support the following operations:
:• ''insert''(&lt;math&gt;x,T&lt;/math&gt;) – Insert item &lt;math&gt;x&lt;/math&gt; into the set &lt;math&gt;T&lt;/math&gt;.
:• ''delete''(&lt;math&gt;k,T&lt;/math&gt;) – Delete the &lt;math&gt;k&lt;/math&gt;th smallest element from &lt;math&gt;T&lt;/math&gt;.
:• ''member''(&lt;math&gt;x,T&lt;/math&gt;) – Return true iff &lt;math&gt;x \in T&lt;/math&gt;.
:All operations must take &lt;math&gt;O(log n)&lt;/math&gt; time on an &lt;math&gt;n&lt;/math&gt;-element set.


:[[3.21]]. A ''concatenate operation'' takes two sets &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt;, where every key in &lt;math&gt;S_1&lt;/math&gt; is smaller than any key in &lt;math&gt;S_2&lt;/math&gt;, and merges them. Give an algorithm to concatenate two binary search trees into one binary search tree. The worst-case running time should be &lt;math&gt;O(h)&lt;/math&gt;, where &lt;math&gt;h&lt;/math&gt; is the maximal height of the two trees.
[[3.21|Solution]]

===Applications of Tree Structures===

:3.22. Design a data structure that supports the following two operations:
:• ''insert''(&lt;math&gt;x&lt;/math&gt;) – Insert item &lt;math&gt;x&lt;/math&gt; from the data stream to the data structure.
:• ''median''() – Return the median of all elements so far.
:All operations must take &lt;math&gt;O(log n)&lt;/math&gt; time on an &lt;math&gt;n&lt;/math&gt;-element set.


:[[3.23]]. Assume we are given a standard dictionary (balanced binary search tree) defined on a set of &lt;math&gt;n&lt;/math&gt; strings, each of length at most &lt;math&gt;l&lt;/math&gt;. We seek to print out all strings beginning with a particular prefix &lt;math&gt;p&lt;/math&gt;. Show how to do this in &lt;math&gt;O(ml log n)&lt;/math&gt; time, where &lt;math&gt;m&lt;/math&gt; is the number of strings.
[[3.23|Solution]]


:3.24. An array &lt;math&gt;A&lt;/math&gt; is called &lt;math&gt;k&lt;/math&gt;-unique if it does not contain a pair of duplicate elements within &lt;math&gt;k&lt;/math&gt; positions of each other, that is, there is no &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; such that &lt;math&gt;A[i] = A[j]&lt;/math&gt; and &lt;math&gt;|j - i| \leq k&lt;/math&gt;. Design a worst-case &lt;math&gt;O(n log k)&lt;/math&gt; algorithm to test if &lt;math&gt;A&lt;/math&gt; is &lt;math&gt;k&lt;/math&gt;-unique.


:[[3.25]]. In the ''bin-packing problem'', we are given &lt;math&gt;n&lt;/math&gt; objects, each weighing at most 1 kilogram. Our goal is to find the smallest number of bins that will hold the &lt;math&gt;n&lt;/math&gt; objects, with each bin holding 1 kilogram at most.
:• The ''best-fit heuristic'' for bin packing is as follows. Consider the objects in the order in which they are given. For each object, place it into the partially filled bin with the smallest amount of extra room after the object is inserted. If no such bin exists, start a new bin. Design an algorithm that implements the best-fit heuristic (taking as input the &lt;math&gt;n&lt;/math&gt; weights &lt;math&gt;w_1, w_2, ..., w_n&lt;/math&gt; and outputting the number of bins used) in &lt;math&gt;O(n log n)&lt;/math&gt; time.
:• Repeat the above using the ''worst-fit heuristic'', where we put the next object into the partially filled bin with the largest amount of extra room after the object is inserted.
[[3.25|Solution]]


:3.26. Suppose that we are given a sequence of &lt;math&gt;n&lt;/math&gt; values &lt;math&gt;x_1, x_2, ..., x_n&lt;/math&gt; and seek to quickly answer repeated queries of the form: given &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt;, find the smallest value in &lt;math&gt;x_i, . . . , x_j&lt;/math&gt;.
:(a) Design a data structure that uses &lt;math&gt;O(n^2)&lt;/math&gt; space and answers queries in &lt;math&gt;O(1)&lt;/math&gt; time.
:(b) Design a data structure that uses &lt;math&gt;O(n)&lt;/math&gt; space and answers queries in &lt;math&gt;O(log n)&lt;/math&gt; time. For partial credit, your data structure can use &lt;math&gt;O(n log n)&lt;/math&gt; space and have &lt;math&gt;O(log n)&lt;/math&gt; query time.


:[[3.27]]. Suppose you are given an input set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, and a black box that if given any sequence of integers and an integer &lt;math&gt;k&lt;/math&gt; instantly and correctly answers whether there is a subset of the input sequence whose sum is exactly &lt;math&gt;k&lt;/math&gt;. Show how to use the black box &lt;math&gt;O(n)&lt;/math&gt; times to find a subset of &lt;math&gt;S&lt;/math&gt; that adds up to &lt;math&gt;k&lt;/math&gt;.
[[3.27|Solution]]


:3.28. Let &lt;math&gt;A[1..n]&lt;/math&gt; be an array of real numbers. Design an algorithm to perform any sequence of the following operations:
:• ''Add''(&lt;math&gt;i,y&lt;/math&gt;) – Add the value &lt;math&gt;y&lt;/math&gt; to the &lt;math&gt;i&lt;/math&gt;th number.
:• ''Partial-sum''(&lt;math&gt;i&lt;/math&gt;) – Return the sum of the first &lt;math&gt;i&lt;/math&gt; numbers, that is, &lt;math&gt;\sum_{j=1}^i A[j]&lt;/math&gt;.
:There are no insertions or deletions; the only change is to the values of the numbers. Each operation should take &lt;math&gt;O(log n)&lt;/math&gt; steps. You may use one additional array of size &lt;math&gt;n&lt;/math&gt; as a work space.


:[[3.29]]. Extend the data structure of the previous problem to support insertions and deletions. Each element now has both a ''key'' and a ''value''. An element is accessed by its key, but the addition operation is applied to the values. The ''Partial_sum'' operation is different.
:• ''Add''(&lt;math&gt;k,y&lt;/math&gt;) – Add the value &lt;math&gt;y&lt;/math&gt; to the item with key &lt;math&gt;k&lt;/math&gt;.
:• ''Insert''(&lt;math&gt;k,y&lt;/math&gt;) – Insert a new item with key &lt;math&gt;k&lt;/math&gt; and value &lt;math&gt;y&lt;/math&gt;.
:• ''Delete''(&lt;math&gt;k&lt;/math&gt;) – Delete the item with key &lt;math&gt;k&lt;/math&gt;.
:• ''Partial-sum''(&lt;math&gt;k&lt;/math&gt;) – Return the sum of all the elements currently in the set whose key is less than &lt;math&gt;k&lt;/math&gt;, that is, &lt;math&gt;\sum_{i &lt; k} x_i&lt;/math&gt;. 
:The worst-case running time should still be &lt;math&gt;O(n log n)&lt;/math&gt; for any sequence of &lt;math&gt;O(n)&lt;/math&gt; operations.
[[3.29|Solution]]


:3.30. You are consulting for a hotel that has &lt;math&gt;n&lt;/math&gt; one-bed rooms. When a guest checks in, they ask for a room whose number is in the range &lt;math&gt;[l, h]&lt;/math&gt;. Propose a data structure that supports the following data operations in the allotted time:
:(a) ''Initialize''(&lt;math&gt;n&lt;/math&gt;): Initialize the data structure for empty rooms numbered &lt;math&gt;1, 2, . . . , n&lt;/math&gt;, in polynomial time.
:(b) ''Count''(&lt;math&gt;l, h&lt;/math&gt;): Return the number of available rooms in &lt;math&gt;[l, h]&lt;/math&gt;, in &lt;math&gt;O(log n)&lt;/math&gt; time.
:(c) ''Checkin''(&lt;math&gt;l, h&lt;/math&gt;): In &lt;math&gt;O(log n)&lt;/math&gt; time, return the first empty room in &lt;math&gt;[l, h]&lt;/math&gt; and mark it occupied, or return NIL if all the rooms in &lt;math&gt;[l, h]&lt;/math&gt; are occupied.
:(d) ''Checkout''(&lt;math&gt;x&lt;/math&gt;): Mark room &lt;math&gt;x&lt;/math&gt; as unoccupied, in &lt;math&gt;O(log n)&lt;/math&gt; time.


:[[3.31]]. Design a data structure that allows one to search, insert, and delete an integer &lt;math&gt;X&lt;/math&gt; in &lt;math&gt;O(1)&lt;/math&gt; time (i.e., constant time, independent of the total number of integers stored). Assume that &lt;math&gt;1 \leq X \leq n&lt;/math&gt; and that there are &lt;math&gt;m + n&lt;/math&gt; units of space available, where &lt;math&gt;m&lt;/math&gt; is the maximum number of integers that can be in the table at any one time. (Hint: use two arrays &lt;math&gt;A[1..n]&lt;/math&gt; and &lt;math&gt;B[1..m]&lt;/math&gt;.) You are not allowed to initialize either &lt;math&gt;A&lt;/math&gt; or &lt;math&gt;B&lt;/math&gt;, as that would take &lt;math&gt;O(m)&lt;/math&gt; or &lt;math&gt;O(n)&lt;/math&gt; operations. This means the arrays are full of random garbage to begin with, so you must be very careful.
[[3.31|Solution]]

===Implementation Projects===

:3.32. Implement versions of several different dictionary data structures, such as linked lists, binary trees, balanced binary search trees, and hash tables. Conduct experiments to assess the relative performance of these data structures in a simple application that reads a large text file and reports exactly one instance of each word that appears within it. This application can be efficiently implemented by maintaining a dictionary of all distinct words that have appeared thus far in the text and inserting/reporting each new word that appears in the stream. Write a brief report with your conclusions.


:[[3.33]]. A Caesar shift (see Section 21.6 (page 697)) is a very simple class of ciphers for secret messages. Unfortunately, they can be broken using statistical properties of English. Develop a program capable of decrypting Caesar shifts of sufficiently long texts.
[[3.33|Solution]]

===Interview Problems===

:3.34. What method would you use to look up a word in a dictionary?


:[[3.35]]. Imagine you have a closet full of shirts. What can you do to organize your shirts for easy retrieval?
[[3.35|Solution]]


:3.36. Write a function to find the middle node of a singly linked list.


:[[3.37]]. Write a function to determine whether two binary trees are identical. Identical trees have the same key value at each position and the same structure.
[[3.37|Solution]]


:3.38. Write a program to convert a binary search tree into a linked list.


:[[3.39]]. Implement an algorithm to reverse a linked list. Now do it without recursion.
[[3.39|Solution]]


:3.40. What is the best data structure for maintaining URLs that have been visited by a web crawler? Give an algorithm to test whether a given URL has already been visited, optimizing both space and time.


:[[3.41]]. You are given a search string and a magazine. You seek to generate all the characters in the search string by cutting them out from the magazine. Give an algorithm to efficiently determine whether the magazine contains all the letters in the search string.
[[3.41|Solution]]


:3.42. Reverse the words in a sentence—that is, “My name is Chris” becomes “Chris is name My.” Optimize for time and space.


:[[3.43]]. Determine whether a linked list contains a loop as quickly as possible without using any extra storage. Also, identify the location of the loop.
[[3.43|Solution]]


:3.44. You have an unordered array &lt;math&gt;X&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers. Find the array &lt;math&gt;M&lt;/math&gt; containing &lt;math&gt;n&lt;/math&gt; elements where &lt;math&gt;M_i&lt;/math&gt; is the product of all integers in &lt;math&gt;X&lt;/math&gt; except for &lt;math&gt;X_i&lt;/math&gt;. You may not use division. You can use extra memory. (Hint: there are solutions faster than &lt;math&gt;O(n^2)&lt;/math&gt;.)


:[[3.45]]. Give an algorithm for finding an ordered word pair (e.g. “New York”) occurring with the greatest frequency in a given webpage. Which data structures would you use? Optimize both time and space.
[[3.45|Solution]]


Back to [[Chapter List]]</text>
      <sha1>km8qjoqkpiozsv7qqnzv7ogkbytq448</sha1>
    </revision>
  </page>
  <page>
    <title>Chapter 4</title>
    <ns>0</ns>
    <id>7</id>
    <revision>
      <id>16</id>
      <timestamp>2020-08-23T19:34:32Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Problems   Back to [[Chapter List]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="35">Problems


Back to [[Chapter List]]</text>
      <sha1>95722ndl4ewzic1ak6z8g4auy0tqhc6</sha1>
    </revision>
    <revision>
      <id>107</id>
      <parentid>16</parentid>
      <timestamp>2020-09-07T18:10:16Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="822">=Sorting=

===Applications of Sorting: Numbers===

:[[4.1]]


:4.2


:[[4.3]]


:4.4


:[[[4.5]]


:4.6


:[[[4.7]]


4.8


[[4.9]]


:4.10


:[[4.11]]


===Applicatoins of Sorting: Intervals and Sets===

:4.12


:[[4.13]]


:4.14


:[[4.15]]


:4.16


===Heaps===

:[[4.17]]


:4.18


:[[4.19]]


:4.20


===Quicksort===

:[[4.21]]


:4.22


:[[4.23]]


:4.24


:[[4.25]]


:4.26


:[[4.27]]


==Mergesort===

:4.28


:[[4.29]]


:4.30


===Other Sorting Alogrithims===

:[[4.31]]


:4.32


:[[4.33]]


:4.34


:[[4.35]]


:4.36


:[[4.37]]


:4.38


===Lower Bounds===

:[[4.39]]


:4.40


===Searching===

:[[4.41]]


:4.42


===Implementaion Challenges]]

:[[4.43]]


:4.44


:[[4.45]]


:4.46


===Interview Problems===

:[[4.47]]


:4.48


:[[4.49]]


:4.50


:[[4.51]]


:4.52


:[[4.53]]


Back to [[Chapter List]]</text>
      <sha1>fxvlgckie9zbo89e7sbfgagsibysha5</sha1>
    </revision>
    <revision>
      <id>108</id>
      <parentid>107</parentid>
      <timestamp>2020-09-07T18:10:38Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Mergesort= */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="823">=Sorting=

===Applications of Sorting: Numbers===

:[[4.1]]


:4.2


:[[4.3]]


:4.4


:[[[4.5]]


:4.6


:[[[4.7]]


4.8


[[4.9]]


:4.10


:[[4.11]]


===Applicatoins of Sorting: Intervals and Sets===

:4.12


:[[4.13]]


:4.14


:[[4.15]]


:4.16


===Heaps===

:[[4.17]]


:4.18


:[[4.19]]


:4.20


===Quicksort===

:[[4.21]]


:4.22


:[[4.23]]


:4.24


:[[4.25]]


:4.26


:[[4.27]]


===Mergesort===

:4.28


:[[4.29]]


:4.30


===Other Sorting Alogrithims===

:[[4.31]]


:4.32


:[[4.33]]


:4.34


:[[4.35]]


:4.36


:[[4.37]]


:4.38


===Lower Bounds===

:[[4.39]]


:4.40


===Searching===

:[[4.41]]


:4.42


===Implementaion Challenges]]

:[[4.43]]


:4.44


:[[4.45]]


:4.46


===Interview Problems===

:[[4.47]]


:4.48


:[[4.49]]


:4.50


:[[4.51]]


:4.52


:[[4.53]]


Back to [[Chapter List]]</text>
      <sha1>aoaoymkld8dycb615cf882atwgvmq18</sha1>
    </revision>
    <revision>
      <id>109</id>
      <parentid>108</parentid>
      <timestamp>2020-09-07T18:10:49Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Searching */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="823">=Sorting=

===Applications of Sorting: Numbers===

:[[4.1]]


:4.2


:[[4.3]]


:4.4


:[[[4.5]]


:4.6


:[[[4.7]]


4.8


[[4.9]]


:4.10


:[[4.11]]


===Applicatoins of Sorting: Intervals and Sets===

:4.12


:[[4.13]]


:4.14


:[[4.15]]


:4.16


===Heaps===

:[[4.17]]


:4.18


:[[4.19]]


:4.20


===Quicksort===

:[[4.21]]


:4.22


:[[4.23]]


:4.24


:[[4.25]]


:4.26


:[[4.27]]


===Mergesort===

:4.28


:[[4.29]]


:4.30


===Other Sorting Alogrithims===

:[[4.31]]


:4.32


:[[4.33]]


:4.34


:[[4.35]]


:4.36


:[[4.37]]


:4.38


===Lower Bounds===

:[[4.39]]


:4.40


===Searching===

:[[4.41]]


:4.42


===Implementaion Challenges===

:[[4.43]]


:4.44


:[[4.45]]


:4.46

===Interview Problems===

:[[4.47]]


:4.48


:[[4.49]]


:4.50


:[[4.51]]


:4.52


:[[4.53]]


Back to [[Chapter List]]</text>
      <sha1>ae4ddpeynuu2densm4lf3k8kntbduit</sha1>
    </revision>
    <revision>
      <id>110</id>
      <parentid>109</parentid>
      <timestamp>2020-09-07T18:11:03Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Applications of Sorting: Numbers */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="820">=Sorting=

===Applications of Sorting: Numbers===

:[[4.1]]


:4.2


:[[4.3]]


:4.4


:[[4.5]]


:4.6


:[[4.7]]


4.8


[[4.9]]


:4.10


:[[4.11]]

===Applicatoins of Sorting: Intervals and Sets===

:4.12


:[[4.13]]


:4.14


:[[4.15]]


:4.16


===Heaps===

:[[4.17]]


:4.18


:[[4.19]]


:4.20


===Quicksort===

:[[4.21]]


:4.22


:[[4.23]]


:4.24


:[[4.25]]


:4.26


:[[4.27]]


===Mergesort===

:4.28


:[[4.29]]


:4.30


===Other Sorting Alogrithims===

:[[4.31]]


:4.32


:[[4.33]]


:4.34


:[[4.35]]


:4.36


:[[4.37]]


:4.38


===Lower Bounds===

:[[4.39]]


:4.40


===Searching===

:[[4.41]]


:4.42


===Implementaion Challenges===

:[[4.43]]


:4.44


:[[4.45]]


:4.46

===Interview Problems===

:[[4.47]]


:4.48


:[[4.49]]


:4.50


:[[4.51]]


:4.52


:[[4.53]]


Back to [[Chapter List]]</text>
      <sha1>nj8j3ilkjm48sl2quih9k7k8ucm7t99</sha1>
    </revision>
    <revision>
      <id>111</id>
      <parentid>110</parentid>
      <timestamp>2020-09-07T18:11:24Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Applications of Sorting: Numbers */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="822">=Sorting=

===Applications of Sorting: Numbers===

:[[4.1]]


:4.2


:[[4.3]]


:4.4


:[[4.5]]


:4.6


:[[4.7]]


:4.8


:[[4.9]]


:4.10


:[[4.11]]

===Applicatoins of Sorting: Intervals and Sets===

:4.12


:[[4.13]]


:4.14


:[[4.15]]


:4.16


===Heaps===

:[[4.17]]


:4.18


:[[4.19]]


:4.20


===Quicksort===

:[[4.21]]


:4.22


:[[4.23]]


:4.24


:[[4.25]]


:4.26


:[[4.27]]


===Mergesort===

:4.28


:[[4.29]]


:4.30


===Other Sorting Alogrithims===

:[[4.31]]


:4.32


:[[4.33]]


:4.34


:[[4.35]]


:4.36


:[[4.37]]


:4.38


===Lower Bounds===

:[[4.39]]


:4.40


===Searching===

:[[4.41]]


:4.42


===Implementaion Challenges===

:[[4.43]]


:4.44


:[[4.45]]


:4.46

===Interview Problems===

:[[4.47]]


:4.48


:[[4.49]]


:4.50


:[[4.51]]


:4.52


:[[4.53]]


Back to [[Chapter List]]</text>
      <sha1>500uhnpzq374emq1sgv8xwvda6gyaoe</sha1>
    </revision>
    <revision>
      <id>263</id>
      <parentid>111</parentid>
      <timestamp>2020-09-18T15:28:59Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Applications of Sorting: Numbers */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="3651">=Sorting=

===Applications of Sorting: Numbers===

:[[4.1]]. The Grinch is given the job of partitioning &lt;math&gt;2n&lt;/math&gt; players into two teams of &lt;math&gt;n&lt;/math&gt; players each. Each player has a numerical rating that measures how good he or she is at the game. The Grinch seeks to divide the players as ''unfairly'' as possible, so as to create the biggest possible talent imbalance between the teams. Show how the Grinch can do the job in &lt;math&gt;O(n log n)&lt;/math&gt; time.
[[4.1|Solution]]


:4.2. For each of the following problems, give an algorithm that finds the desired numbers within the given amount of time. To keep your answers brief, feel free to use algorithms from the book as subroutines. For the example, &lt;math&gt;S = {6, 13, 19, 3, 8}&lt;/math&gt;, 19 - 3 maximizes the difference, while 8 - 6 minimizes the difference.
:(a) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x-y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.
:(b) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x - y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(1)&lt;/math&gt; worst-case time.
:(c) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n log n)&lt;/math&gt; worst-case time.
:(d) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.


:[[4.3]]. Take a list of &lt;math&gt;2n&lt;/math&gt; real numbers as input. Design an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm that partitions the numbers into &lt;math&gt;n&lt;/math&gt; pairs, with the property that the partition minimizes the maximum sum of a pair. For example, say we are given the numbers (1,3,5,9). The possible partitions are ((1,3),(5,9)), ((1,5),(3,9)), and ((1,9),(3,5)). The pair sums for these partitions are (4,14), (6,12), and (10,8). Thus, the third partition has 10 as its maximum sum, which is the minimum
over the three partitions.
[[4.3|Solution]]


:4.4. Assume that we are given &lt;math&gt;n&lt;/math&gt; pairs of items as input, where the first item is a number and the second item is one of three colors (red, blue, or yellow). Further assume that the items are sorted by number. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm to sort the items by color (all reds before all blues before all yellows) such that the numbers for identical colors stay sorted.
:For example: (1,blue), (3,red), (4,blue), (6,yellow), (9,red) should become (3,red), (9,red), (1,blue), (4,blue), (6,yellow).


:[[4.5]]


:4.6


:[[4.7]]


:4.8


:[[4.9]]


:4.10


:[[4.11]]

===Applicatoins of Sorting: Intervals and Sets===

:4.12


:[[4.13]]


:4.14


:[[4.15]]


:4.16


===Heaps===

:[[4.17]]


:4.18


:[[4.19]]


:4.20


===Quicksort===

:[[4.21]]


:4.22


:[[4.23]]


:4.24


:[[4.25]]


:4.26


:[[4.27]]


===Mergesort===

:4.28


:[[4.29]]


:4.30


===Other Sorting Alogrithims===

:[[4.31]]


:4.32


:[[4.33]]


:4.34


:[[4.35]]


:4.36


:[[4.37]]


:4.38


===Lower Bounds===

:[[4.39]]


:4.40


===Searching===

:[[4.41]]


:4.42


===Implementaion Challenges===

:[[4.43]]


:4.44


:[[4.45]]


:4.46

===Interview Problems===

:[[4.47]]


:4.48


:[[4.49]]


:4.50


:[[4.51]]


:4.52


:[[4.53]]


Back to [[Chapter List]]</text>
      <sha1>poub79bxi68jl35l5sq83ku0c4b1r0d</sha1>
    </revision>
    <revision>
      <id>264</id>
      <parentid>263</parentid>
      <timestamp>2020-09-18T15:29:25Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Sorting */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="3651">=Sorting=

===Applications of Sorting: Numbers===

:[[4.1]]. The Grinch is given the job of partitioning &lt;math&gt;2n&lt;/math&gt; players into two teams of &lt;math&gt;n&lt;/math&gt; players each. Each player has a numerical rating that measures how good he or she is at the game. The Grinch seeks to divide the players as ''unfairly'' as possible, so as to create the biggest possible talent imbalance between the teams. Show how the Grinch can do the job in &lt;math&gt;O(n log n)&lt;/math&gt; time.
[[4.1|Solution]]


:4.2. For each of the following problems, give an algorithm that finds the desired numbers within the given amount of time. To keep your answers brief, feel free to use algorithms from the book as subroutines. For the example, &lt;math&gt;S = {6, 13, 19, 3, 8}&lt;/math&gt;, 19 - 3 maximizes the difference, while 8 - 6 minimizes the difference.
:(a) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x-y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.
:(b) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x - y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(1)&lt;/math&gt; worst-case time.
:(c) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n log n)&lt;/math&gt; worst-case time.
:(d) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.


:[[4.3]]. Take a list of &lt;math&gt;2n&lt;/math&gt; real numbers as input. Design an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm that partitions the numbers into &lt;math&gt;n&lt;/math&gt; pairs, with the property that the partition minimizes the maximum sum of a pair. For example, say we are given the numbers (1,3,5,9). The possible partitions are ((1,3),(5,9)), ((1,5),(3,9)), and ((1,9),(3,5)). The pair sums for these partitions are (4,14), (6,12), and (10,8). Thus, the third partition has 10 as its maximum sum, which is the minimum over the three partitions.
[[4.3|Solution]]


:4.4. Assume that we are given &lt;math&gt;n&lt;/math&gt; pairs of items as input, where the first item is a number and the second item is one of three colors (red, blue, or yellow). Further assume that the items are sorted by number. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm to sort the items by color (all reds before all blues before all yellows) such that the numbers for identical colors stay sorted.
:For example: (1,blue), (3,red), (4,blue), (6,yellow), (9,red) should become (3,red), (9,red), (1,blue), (4,blue), (6,yellow).


:[[4.5]]


:4.6


:[[4.7]]


:4.8


:[[4.9]]


:4.10


:[[4.11]]

===Applicatoins of Sorting: Intervals and Sets===

:4.12


:[[4.13]]


:4.14


:[[4.15]]


:4.16


===Heaps===

:[[4.17]]


:4.18


:[[4.19]]


:4.20


===Quicksort===

:[[4.21]]


:4.22


:[[4.23]]


:4.24


:[[4.25]]


:4.26


:[[4.27]]


===Mergesort===

:4.28


:[[4.29]]


:4.30


===Other Sorting Alogrithims===

:[[4.31]]


:4.32


:[[4.33]]


:4.34


:[[4.35]]


:4.36


:[[4.37]]


:4.38


===Lower Bounds===

:[[4.39]]


:4.40


===Searching===

:[[4.41]]


:4.42


===Implementaion Challenges===

:[[4.43]]


:4.44


:[[4.45]]


:4.46

===Interview Problems===

:[[4.47]]


:4.48


:[[4.49]]


:4.50


:[[4.51]]


:4.52


:[[4.53]]


Back to [[Chapter List]]</text>
      <sha1>hrqbshtghcklecm6uvbfpcsy4yti5vy</sha1>
    </revision>
    <revision>
      <id>266</id>
      <parentid>264</parentid>
      <timestamp>2020-09-19T18:52:01Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Applications of Sorting: Numbers */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="6482">=Sorting=

===Applications of Sorting: Numbers===

:[[4.1]]. The Grinch is given the job of partitioning &lt;math&gt;2n&lt;/math&gt; players into two teams of &lt;math&gt;n&lt;/math&gt; players each. Each player has a numerical rating that measures how good he or she is at the game. The Grinch seeks to divide the players as ''unfairly'' as possible, so as to create the biggest possible talent imbalance between the teams. Show how the Grinch can do the job in &lt;math&gt;O(n log n)&lt;/math&gt; time.
[[4.1|Solution]]


:4.2. For each of the following problems, give an algorithm that finds the desired numbers within the given amount of time. To keep your answers brief, feel free to use algorithms from the book as subroutines. For the example, &lt;math&gt;S = {6, 13, 19, 3, 8}&lt;/math&gt;, 19 - 3 maximizes the difference, while 8 - 6 minimizes the difference.
:(a) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x-y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.
:(b) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x - y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(1)&lt;/math&gt; worst-case time.
:(c) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n log n)&lt;/math&gt; worst-case time.
:(d) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.


:[[4.3]]. Take a list of &lt;math&gt;2n&lt;/math&gt; real numbers as input. Design an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm that partitions the numbers into &lt;math&gt;n&lt;/math&gt; pairs, with the property that the partition minimizes the maximum sum of a pair. For example, say we are given the numbers (1,3,5,9). The possible partitions are ((1,3),(5,9)), ((1,5),(3,9)), and ((1,9),(3,5)). The pair sums for these partitions are (4,14), (6,12), and (10,8). Thus, the third partition has 10 as its maximum sum, which is the minimum over the three partitions.
[[4.3|Solution]]


:4.4. Assume that we are given &lt;math&gt;n&lt;/math&gt; pairs of items as input, where the first item is a number and the second item is one of three colors (red, blue, or yellow). Further assume that the items are sorted by number. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm to sort the items by color (all reds before all blues before all yellows) such that the numbers for identical colors stay sorted.
:For example: (1,blue), (3,red), (4,blue), (6,yellow), (9,red) should become (3,red), (9,red), (1,blue), (4,blue), (6,yellow).


:[[4.5]]. The ''mode'' of a bag of numbers is the number that occurs most frequently in the set. The set {4, 6, 2, 4, 3, 1} has a mode of 4. Give an efficient and correct algorithm to compute the mode of a bag of &lt;math&gt;n&lt;/math&gt; numbers.
[[4.5|Solution]]


:4.6. Given two sets &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt; (each of size &lt;math&gt;n&lt;/math&gt;), and a number &lt;math&gt;x&lt;/math&gt;, describe an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for finding whether there exists a pair of elements, one from &lt;math&gt;S_1&lt;/math&gt; and one from &lt;math&gt;S_2&lt;/math&gt;, that add up to &lt;math&gt;x&lt;/math&gt;. (For partial credit, give a &lt;math&gt;\Theta(n^2)&lt;/math&gt; algorithm for this problem.)


:[[4.7]]. Give an efficient algorithm to take the array of citation counts (each count is a non-negative integer) of a researcher’s papers, and compute the researcher’s &lt;math&gt;h&lt;/math&gt;-index. By definition, a scientist has index &lt;math&gt;h&lt;/math&gt; if &lt;math&gt;h&lt;/math&gt; of his or her &lt;math&gt;n&lt;/math&gt; papers have been cited at least &lt;math&gt;h&lt;/math&gt; times, while the other &lt;math&gt;n-h&lt;/math&gt; papers each have no more than &lt;math&gt;h&lt;/math&gt; citations.
[[4.7|Solution]]


:4.8. Outline a reasonable method of solving each of the following problems. Give the order of the worst-case complexity of your methods.
:(a) You are given a pile of thousands of telephone bills and thousands of checks sent in to pay the bills. Find out who did not pay.
:(b) You are given a printed list containing the title, author, call number, and publisher of all the books in a school library and another list of thirty publishers. Find out how many of the books in the library were published by each company.
:(c) You are given all the book checkout cards used in the campus library during the past year, each of which contains the name of the person who took out the book. Determine how many distinct people checked out at least one book.


:[[4.9]]. Given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers and an integer &lt;math&gt;T&lt;/math&gt;, give an &lt;math&gt;O(n^{k-1}log n)&lt;/math&gt; algorithm to test whether &lt;math&gt;k&lt;/math&gt; of the integers in &lt;math&gt;S&lt;/math&gt; add up to &lt;math&gt;T.
[[4.9|Solution]]


:4.10. We are given a set of &lt;math&gt;S&lt;/math&gt; containing &lt;math&gt;n&lt;/math&gt; real numbers and a real number &lt;math&gt;x&lt;/math&gt;, and seek efficient algorithms to determine whether two elements of &lt;math&gt;S&lt;/math&gt; exist whose sum is exactly &lt;math&gt;x&lt;/math&gt;.
:(a) Assume that &lt;math&gt;S&lt;/math&gt; is unsorted. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for the problem.
:(b) Assume that &lt;math&gt;S&lt;/math&gt; is sorted. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for the problem.


:[[4.11]]. Design an &lt;math&gt;O(n)&lt;/math&gt; algorithm that, given a list of &lt;math&gt;n&lt;/math&gt; elements, finds all the elements that appear more than &lt;math&gt;n/2&lt;/math&gt; times in the list. Then, design an &lt;math&gt;O(n)&lt;/math&gt; algorithm that, given a list of &lt;math&gt;n&lt;/math&gt; elements, finds all the elements that appear more than &lt;math&gt;n/4&lt;/math&gt; times.
[[4.11|Solution]]

===Applicatoins of Sorting: Intervals and Sets===

:4.12


:[[4.13]]


:4.14


:[[4.15]]


:4.16


===Heaps===

:[[4.17]]


:4.18


:[[4.19]]


:4.20


===Quicksort===

:[[4.21]]


:4.22


:[[4.23]]


:4.24


:[[4.25]]


:4.26


:[[4.27]]


===Mergesort===

:4.28


:[[4.29]]


:4.30


===Other Sorting Alogrithims===

:[[4.31]]


:4.32


:[[4.33]]


:4.34


:[[4.35]]


:4.36


:[[4.37]]


:4.38


===Lower Bounds===

:[[4.39]]


:4.40


===Searching===

:[[4.41]]


:4.42


===Implementaion Challenges===

:[[4.43]]


:4.44


:[[4.45]]


:4.46

===Interview Problems===

:[[4.47]]


:4.48


:[[4.49]]


:4.50


:[[4.51]]


:4.52


:[[4.53]]


Back to [[Chapter List]]</text>
      <sha1>3rosohg24nv59scu9szalccptnkb10p</sha1>
    </revision>
    <revision>
      <id>267</id>
      <parentid>266</parentid>
      <timestamp>2020-09-19T18:52:36Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Applications of Sorting: Numbers */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="6489">=Sorting=

===Applications of Sorting: Numbers===

:[[4.1]]. The Grinch is given the job of partitioning &lt;math&gt;2n&lt;/math&gt; players into two teams of &lt;math&gt;n&lt;/math&gt; players each. Each player has a numerical rating that measures how good he or she is at the game. The Grinch seeks to divide the players as ''unfairly'' as possible, so as to create the biggest possible talent imbalance between the teams. Show how the Grinch can do the job in &lt;math&gt;O(n log n)&lt;/math&gt; time.
[[4.1|Solution]]


:4.2. For each of the following problems, give an algorithm that finds the desired numbers within the given amount of time. To keep your answers brief, feel free to use algorithms from the book as subroutines. For the example, &lt;math&gt;S = {6, 13, 19, 3, 8}&lt;/math&gt;, 19 - 3 maximizes the difference, while 8 - 6 minimizes the difference.
:(a) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x-y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.
:(b) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x - y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(1)&lt;/math&gt; worst-case time.
:(c) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n log n)&lt;/math&gt; worst-case time.
:(d) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.


:[[4.3]]. Take a list of &lt;math&gt;2n&lt;/math&gt; real numbers as input. Design an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm that partitions the numbers into &lt;math&gt;n&lt;/math&gt; pairs, with the property that the partition minimizes the maximum sum of a pair. For example, say we are given the numbers (1,3,5,9). The possible partitions are ((1,3),(5,9)), ((1,5),(3,9)), and ((1,9),(3,5)). The pair sums for these partitions are (4,14), (6,12), and (10,8). Thus, the third partition has 10 as its maximum sum, which is the minimum over the three partitions.
[[4.3|Solution]]


:4.4. Assume that we are given &lt;math&gt;n&lt;/math&gt; pairs of items as input, where the first item is a number and the second item is one of three colors (red, blue, or yellow). Further assume that the items are sorted by number. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm to sort the items by color (all reds before all blues before all yellows) such that the numbers for identical colors stay sorted.
:For example: (1,blue), (3,red), (4,blue), (6,yellow), (9,red) should become (3,red), (9,red), (1,blue), (4,blue), (6,yellow).


:[[4.5]]. The ''mode'' of a bag of numbers is the number that occurs most frequently in the set. The set {4, 6, 2, 4, 3, 1} has a mode of 4. Give an efficient and correct algorithm to compute the mode of a bag of &lt;math&gt;n&lt;/math&gt; numbers.
[[4.5|Solution]]


:4.6. Given two sets &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt; (each of size &lt;math&gt;n&lt;/math&gt;), and a number &lt;math&gt;x&lt;/math&gt;, describe an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for finding whether there exists a pair of elements, one from &lt;math&gt;S_1&lt;/math&gt; and one from &lt;math&gt;S_2&lt;/math&gt;, that add up to &lt;math&gt;x&lt;/math&gt;. (For partial credit, give a &lt;math&gt;\Theta(n^2)&lt;/math&gt; algorithm for this problem.)


:[[4.7]]. Give an efficient algorithm to take the array of citation counts (each count is a non-negative integer) of a researcher’s papers, and compute the researcher’s &lt;math&gt;h&lt;/math&gt;-index. By definition, a scientist has index &lt;math&gt;h&lt;/math&gt; if &lt;math&gt;h&lt;/math&gt; of his or her &lt;math&gt;n&lt;/math&gt; papers have been cited at least &lt;math&gt;h&lt;/math&gt; times, while the other &lt;math&gt;n-h&lt;/math&gt; papers each have no more than &lt;math&gt;h&lt;/math&gt; citations.
[[4.7|Solution]]


:4.8. Outline a reasonable method of solving each of the following problems. Give the order of the worst-case complexity of your methods.
:(a) You are given a pile of thousands of telephone bills and thousands of checks sent in to pay the bills. Find out who did not pay.
:(b) You are given a printed list containing the title, author, call number, and publisher of all the books in a school library and another list of thirty publishers. Find out how many of the books in the library were published by each company.
:(c) You are given all the book checkout cards used in the campus library during the past year, each of which contains the name of the person who took out the book. Determine how many distinct people checked out at least one book.


:[[4.9]]. Given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers and an integer &lt;math&gt;T&lt;/math&gt;, give an &lt;math&gt;O(n^{k-1}log n)&lt;/math&gt; algorithm to test whether &lt;math&gt;k&lt;/math&gt; of the integers in &lt;math&gt;S&lt;/math&gt; add up to &lt;math&gt;T&lt;/math&gt;.
[[4.9|Solution]]


:4.10. We are given a set of &lt;math&gt;S&lt;/math&gt; containing &lt;math&gt;n&lt;/math&gt; real numbers and a real number &lt;math&gt;x&lt;/math&gt;, and seek efficient algorithms to determine whether two elements of &lt;math&gt;S&lt;/math&gt; exist whose sum is exactly &lt;math&gt;x&lt;/math&gt;.
:(a) Assume that &lt;math&gt;S&lt;/math&gt; is unsorted. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for the problem.
:(b) Assume that &lt;math&gt;S&lt;/math&gt; is sorted. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for the problem.


:[[4.11]]. Design an &lt;math&gt;O(n)&lt;/math&gt; algorithm that, given a list of &lt;math&gt;n&lt;/math&gt; elements, finds all the elements that appear more than &lt;math&gt;n/2&lt;/math&gt; times in the list. Then, design an &lt;math&gt;O(n)&lt;/math&gt; algorithm that, given a list of &lt;math&gt;n&lt;/math&gt; elements, finds all the elements that appear more than &lt;math&gt;n/4&lt;/math&gt; times.
[[4.11|Solution]]

===Applicatoins of Sorting: Intervals and Sets===

:4.12


:[[4.13]]


:4.14


:[[4.15]]


:4.16


===Heaps===

:[[4.17]]


:4.18


:[[4.19]]


:4.20


===Quicksort===

:[[4.21]]


:4.22


:[[4.23]]


:4.24


:[[4.25]]


:4.26


:[[4.27]]


===Mergesort===

:4.28


:[[4.29]]


:4.30


===Other Sorting Alogrithims===

:[[4.31]]


:4.32


:[[4.33]]


:4.34


:[[4.35]]


:4.36


:[[4.37]]


:4.38


===Lower Bounds===

:[[4.39]]


:4.40


===Searching===

:[[4.41]]


:4.42


===Implementaion Challenges===

:[[4.43]]


:4.44


:[[4.45]]


:4.46

===Interview Problems===

:[[4.47]]


:4.48


:[[4.49]]


:4.50


:[[4.51]]


:4.52


:[[4.53]]


Back to [[Chapter List]]</text>
      <sha1>t1t41roq1w7qmeuswl8d2hx02u4kqdg</sha1>
    </revision>
    <revision>
      <id>268</id>
      <parentid>267</parentid>
      <timestamp>2020-09-19T19:35:26Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Applicatoins of Sorting: Intervals and Sets */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="8588">=Sorting=

===Applications of Sorting: Numbers===

:[[4.1]]. The Grinch is given the job of partitioning &lt;math&gt;2n&lt;/math&gt; players into two teams of &lt;math&gt;n&lt;/math&gt; players each. Each player has a numerical rating that measures how good he or she is at the game. The Grinch seeks to divide the players as ''unfairly'' as possible, so as to create the biggest possible talent imbalance between the teams. Show how the Grinch can do the job in &lt;math&gt;O(n log n)&lt;/math&gt; time.
[[4.1|Solution]]


:4.2. For each of the following problems, give an algorithm that finds the desired numbers within the given amount of time. To keep your answers brief, feel free to use algorithms from the book as subroutines. For the example, &lt;math&gt;S = {6, 13, 19, 3, 8}&lt;/math&gt;, 19 - 3 maximizes the difference, while 8 - 6 minimizes the difference.
:(a) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x-y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.
:(b) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x - y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(1)&lt;/math&gt; worst-case time.
:(c) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n log n)&lt;/math&gt; worst-case time.
:(d) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.


:[[4.3]]. Take a list of &lt;math&gt;2n&lt;/math&gt; real numbers as input. Design an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm that partitions the numbers into &lt;math&gt;n&lt;/math&gt; pairs, with the property that the partition minimizes the maximum sum of a pair. For example, say we are given the numbers (1,3,5,9). The possible partitions are ((1,3),(5,9)), ((1,5),(3,9)), and ((1,9),(3,5)). The pair sums for these partitions are (4,14), (6,12), and (10,8). Thus, the third partition has 10 as its maximum sum, which is the minimum over the three partitions.
[[4.3|Solution]]


:4.4. Assume that we are given &lt;math&gt;n&lt;/math&gt; pairs of items as input, where the first item is a number and the second item is one of three colors (red, blue, or yellow). Further assume that the items are sorted by number. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm to sort the items by color (all reds before all blues before all yellows) such that the numbers for identical colors stay sorted.
:For example: (1,blue), (3,red), (4,blue), (6,yellow), (9,red) should become (3,red), (9,red), (1,blue), (4,blue), (6,yellow).


:[[4.5]]. The ''mode'' of a bag of numbers is the number that occurs most frequently in the set. The set {4, 6, 2, 4, 3, 1} has a mode of 4. Give an efficient and correct algorithm to compute the mode of a bag of &lt;math&gt;n&lt;/math&gt; numbers.
[[4.5|Solution]]


:4.6. Given two sets &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt; (each of size &lt;math&gt;n&lt;/math&gt;), and a number &lt;math&gt;x&lt;/math&gt;, describe an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for finding whether there exists a pair of elements, one from &lt;math&gt;S_1&lt;/math&gt; and one from &lt;math&gt;S_2&lt;/math&gt;, that add up to &lt;math&gt;x&lt;/math&gt;. (For partial credit, give a &lt;math&gt;\Theta(n^2)&lt;/math&gt; algorithm for this problem.)


:[[4.7]]. Give an efficient algorithm to take the array of citation counts (each count is a non-negative integer) of a researcher’s papers, and compute the researcher’s &lt;math&gt;h&lt;/math&gt;-index. By definition, a scientist has index &lt;math&gt;h&lt;/math&gt; if &lt;math&gt;h&lt;/math&gt; of his or her &lt;math&gt;n&lt;/math&gt; papers have been cited at least &lt;math&gt;h&lt;/math&gt; times, while the other &lt;math&gt;n-h&lt;/math&gt; papers each have no more than &lt;math&gt;h&lt;/math&gt; citations.
[[4.7|Solution]]


:4.8. Outline a reasonable method of solving each of the following problems. Give the order of the worst-case complexity of your methods.
:(a) You are given a pile of thousands of telephone bills and thousands of checks sent in to pay the bills. Find out who did not pay.
:(b) You are given a printed list containing the title, author, call number, and publisher of all the books in a school library and another list of thirty publishers. Find out how many of the books in the library were published by each company.
:(c) You are given all the book checkout cards used in the campus library during the past year, each of which contains the name of the person who took out the book. Determine how many distinct people checked out at least one book.


:[[4.9]]. Given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers and an integer &lt;math&gt;T&lt;/math&gt;, give an &lt;math&gt;O(n^{k-1}log n)&lt;/math&gt; algorithm to test whether &lt;math&gt;k&lt;/math&gt; of the integers in &lt;math&gt;S&lt;/math&gt; add up to &lt;math&gt;T&lt;/math&gt;.
[[4.9|Solution]]


:4.10. We are given a set of &lt;math&gt;S&lt;/math&gt; containing &lt;math&gt;n&lt;/math&gt; real numbers and a real number &lt;math&gt;x&lt;/math&gt;, and seek efficient algorithms to determine whether two elements of &lt;math&gt;S&lt;/math&gt; exist whose sum is exactly &lt;math&gt;x&lt;/math&gt;.
:(a) Assume that &lt;math&gt;S&lt;/math&gt; is unsorted. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for the problem.
:(b) Assume that &lt;math&gt;S&lt;/math&gt; is sorted. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for the problem.


:[[4.11]]. Design an &lt;math&gt;O(n)&lt;/math&gt; algorithm that, given a list of &lt;math&gt;n&lt;/math&gt; elements, finds all the elements that appear more than &lt;math&gt;n/2&lt;/math&gt; times in the list. Then, design an &lt;math&gt;O(n)&lt;/math&gt; algorithm that, given a list of &lt;math&gt;n&lt;/math&gt; elements, finds all the elements that appear more than &lt;math&gt;n/4&lt;/math&gt; times.
[[4.11|Solution]]

===Applications of Sorting: Intervals and Sets===

:4.12. Give an efficient algorithm to compute the union of sets &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt;, where &lt;math&gt;n = max(|A|, |B|)&lt;/math&gt;. The output should be an array of distinct elements that form the union of the sets.
:(a) Assume that &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; are unsorted arrays. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for the problem.
:(b) Assume that &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; are sorted arrays. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for the problem.


:[[4.13]]. A camera at the door tracks the entry time &lt;math&gt;a_i&lt;/math&gt; and exit time &lt;math&gt;b_i&lt;/math&gt; (assume &lt;math&gt;b_i &gt; a_i&lt;/math&gt;) for each of &lt;math&gt;n&lt;/math&gt; persons &lt;math&gt;p_i&lt;/math&gt; attending a party. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm that analyzes this data to determine the time when the most people were simultaneously present at the party. You may assume that all entry and exit times are distinct (no ties).
[[4.13|Solution]]


:4.14. Given a list &lt;math&gt;I&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; intervals, specified as &lt;math&gt;(x_i, y_i)&lt;/math&gt; pairs, return a list where the overlapping intervals are merged. For &lt;math&gt;I = {(1, 3),(2, 6),(8, 10),(7, 18)}&lt;/math&gt; the output should be {(1, 6),(7, 18)}. Your algorithm should run in worst-case &lt;math&gt;O(n log n)&lt;/math&gt; time complexity.


:[[4.15]]. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; intervals on a line, with the &lt;math&gt;i&lt;/math&gt;th interval described by its left and right endpoints &lt;math&gt;(l_i, r_i)&lt;/math&gt;. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm to identify a point &lt;math&gt;p&lt;/math&gt; on the line that is in the largest number of intervals.
:As an example, for &lt;math&gt;S = {(10, 40),(20, 60),(50, 90),(15, 70)}&lt;/math&gt; no point exists in all four intervals, but &lt;math&gt;p = 50&lt;/math&gt; is an example of a point in three intervals. You can assume an endpoint counts as being in its interval.
[[4.15|Solution]]


:4.16. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; segments on the line, where segment &lt;math&gt;S_i&lt;/math&gt; ranges from &lt;math&gt;l_i&lt;/math&gt; to &lt;math&gt;r_i&lt;/math&gt;. Give an efficient algorithm to select the fewest number of segments whose union completely covers the interval from 0 to &lt;math&gt;m&lt;/math&gt;.

===Heaps===

:[[4.17]]


:4.18


:[[4.19]]


:4.20


===Quicksort===

:[[4.21]]


:4.22


:[[4.23]]


:4.24


:[[4.25]]


:4.26


:[[4.27]]


===Mergesort===

:4.28


:[[4.29]]


:4.30


===Other Sorting Alogrithims===

:[[4.31]]


:4.32


:[[4.33]]


:4.34


:[[4.35]]


:4.36


:[[4.37]]


:4.38


===Lower Bounds===

:[[4.39]]


:4.40


===Searching===

:[[4.41]]


:4.42


===Implementaion Challenges===

:[[4.43]]


:4.44


:[[4.45]]


:4.46

===Interview Problems===

:[[4.47]]


:4.48


:[[4.49]]


:4.50


:[[4.51]]


:4.52


:[[4.53]]


Back to [[Chapter List]]</text>
      <sha1>hff1rku2rywhx28lwvojaubkzp6lumq</sha1>
    </revision>
    <revision>
      <id>269</id>
      <parentid>268</parentid>
      <timestamp>2020-09-19T19:36:03Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Applications of Sorting: Intervals and Sets */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="8601">=Sorting=

===Applications of Sorting: Numbers===

:[[4.1]]. The Grinch is given the job of partitioning &lt;math&gt;2n&lt;/math&gt; players into two teams of &lt;math&gt;n&lt;/math&gt; players each. Each player has a numerical rating that measures how good he or she is at the game. The Grinch seeks to divide the players as ''unfairly'' as possible, so as to create the biggest possible talent imbalance between the teams. Show how the Grinch can do the job in &lt;math&gt;O(n log n)&lt;/math&gt; time.
[[4.1|Solution]]


:4.2. For each of the following problems, give an algorithm that finds the desired numbers within the given amount of time. To keep your answers brief, feel free to use algorithms from the book as subroutines. For the example, &lt;math&gt;S = {6, 13, 19, 3, 8}&lt;/math&gt;, 19 - 3 maximizes the difference, while 8 - 6 minimizes the difference.
:(a) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x-y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.
:(b) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x - y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(1)&lt;/math&gt; worst-case time.
:(c) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n log n)&lt;/math&gt; worst-case time.
:(d) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.


:[[4.3]]. Take a list of &lt;math&gt;2n&lt;/math&gt; real numbers as input. Design an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm that partitions the numbers into &lt;math&gt;n&lt;/math&gt; pairs, with the property that the partition minimizes the maximum sum of a pair. For example, say we are given the numbers (1,3,5,9). The possible partitions are ((1,3),(5,9)), ((1,5),(3,9)), and ((1,9),(3,5)). The pair sums for these partitions are (4,14), (6,12), and (10,8). Thus, the third partition has 10 as its maximum sum, which is the minimum over the three partitions.
[[4.3|Solution]]


:4.4. Assume that we are given &lt;math&gt;n&lt;/math&gt; pairs of items as input, where the first item is a number and the second item is one of three colors (red, blue, or yellow). Further assume that the items are sorted by number. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm to sort the items by color (all reds before all blues before all yellows) such that the numbers for identical colors stay sorted.
:For example: (1,blue), (3,red), (4,blue), (6,yellow), (9,red) should become (3,red), (9,red), (1,blue), (4,blue), (6,yellow).


:[[4.5]]. The ''mode'' of a bag of numbers is the number that occurs most frequently in the set. The set {4, 6, 2, 4, 3, 1} has a mode of 4. Give an efficient and correct algorithm to compute the mode of a bag of &lt;math&gt;n&lt;/math&gt; numbers.
[[4.5|Solution]]


:4.6. Given two sets &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt; (each of size &lt;math&gt;n&lt;/math&gt;), and a number &lt;math&gt;x&lt;/math&gt;, describe an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for finding whether there exists a pair of elements, one from &lt;math&gt;S_1&lt;/math&gt; and one from &lt;math&gt;S_2&lt;/math&gt;, that add up to &lt;math&gt;x&lt;/math&gt;. (For partial credit, give a &lt;math&gt;\Theta(n^2)&lt;/math&gt; algorithm for this problem.)


:[[4.7]]. Give an efficient algorithm to take the array of citation counts (each count is a non-negative integer) of a researcher’s papers, and compute the researcher’s &lt;math&gt;h&lt;/math&gt;-index. By definition, a scientist has index &lt;math&gt;h&lt;/math&gt; if &lt;math&gt;h&lt;/math&gt; of his or her &lt;math&gt;n&lt;/math&gt; papers have been cited at least &lt;math&gt;h&lt;/math&gt; times, while the other &lt;math&gt;n-h&lt;/math&gt; papers each have no more than &lt;math&gt;h&lt;/math&gt; citations.
[[4.7|Solution]]


:4.8. Outline a reasonable method of solving each of the following problems. Give the order of the worst-case complexity of your methods.
:(a) You are given a pile of thousands of telephone bills and thousands of checks sent in to pay the bills. Find out who did not pay.
:(b) You are given a printed list containing the title, author, call number, and publisher of all the books in a school library and another list of thirty publishers. Find out how many of the books in the library were published by each company.
:(c) You are given all the book checkout cards used in the campus library during the past year, each of which contains the name of the person who took out the book. Determine how many distinct people checked out at least one book.


:[[4.9]]. Given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers and an integer &lt;math&gt;T&lt;/math&gt;, give an &lt;math&gt;O(n^{k-1}log n)&lt;/math&gt; algorithm to test whether &lt;math&gt;k&lt;/math&gt; of the integers in &lt;math&gt;S&lt;/math&gt; add up to &lt;math&gt;T&lt;/math&gt;.
[[4.9|Solution]]


:4.10. We are given a set of &lt;math&gt;S&lt;/math&gt; containing &lt;math&gt;n&lt;/math&gt; real numbers and a real number &lt;math&gt;x&lt;/math&gt;, and seek efficient algorithms to determine whether two elements of &lt;math&gt;S&lt;/math&gt; exist whose sum is exactly &lt;math&gt;x&lt;/math&gt;.
:(a) Assume that &lt;math&gt;S&lt;/math&gt; is unsorted. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for the problem.
:(b) Assume that &lt;math&gt;S&lt;/math&gt; is sorted. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for the problem.


:[[4.11]]. Design an &lt;math&gt;O(n)&lt;/math&gt; algorithm that, given a list of &lt;math&gt;n&lt;/math&gt; elements, finds all the elements that appear more than &lt;math&gt;n/2&lt;/math&gt; times in the list. Then, design an &lt;math&gt;O(n)&lt;/math&gt; algorithm that, given a list of &lt;math&gt;n&lt;/math&gt; elements, finds all the elements that appear more than &lt;math&gt;n/4&lt;/math&gt; times.
[[4.11|Solution]]

===Applications of Sorting: Intervals and Sets===

:4.12. Give an efficient algorithm to compute the union of sets &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt;, where &lt;math&gt;n = max(|A|, |B|)&lt;/math&gt;. The output should be an array of distinct elements that form the union of the sets.
:(a) Assume that &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; are unsorted arrays. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for the problem.
:(b) Assume that &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; are sorted arrays. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for the problem.


:[[4.13]]. A camera at the door tracks the entry time &lt;math&gt;a_i&lt;/math&gt; and exit time &lt;math&gt;b_i&lt;/math&gt; (assume &lt;math&gt;b_i &gt; a_i&lt;/math&gt;) for each of &lt;math&gt;n&lt;/math&gt; persons &lt;math&gt;p_i&lt;/math&gt; attending a party. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm that analyzes this data to determine the time when the most people were simultaneously present at the party. You may assume that all entry and exit times are distinct (no ties).
[[4.13|Solution]]


:4.14. Given a list &lt;math&gt;I&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; intervals, specified as &lt;math&gt;(x_i, y_i)&lt;/math&gt; pairs, return a list where the overlapping intervals are merged. For &lt;math&gt;I = {(1, 3),(2, 6),(8, 10),(7, 18)}&lt;/math&gt; the output should be &lt;math&gt;{(1, 6),(7, 18)}&lt;/math&gt;. Your algorithm should run in worst-case &lt;math&gt;O(n log n)&lt;/math&gt; time complexity.


:[[4.15]]. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; intervals on a line, with the &lt;math&gt;i&lt;/math&gt;th interval described by its left and right endpoints &lt;math&gt;(l_i, r_i)&lt;/math&gt;. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm to identify a point &lt;math&gt;p&lt;/math&gt; on the line that is in the largest number of intervals.
:As an example, for &lt;math&gt;S = {(10, 40),(20, 60),(50, 90),(15, 70)}&lt;/math&gt; no point exists in all four intervals, but &lt;math&gt;p = 50&lt;/math&gt; is an example of a point in three intervals. You can assume an endpoint counts as being in its interval.
[[4.15|Solution]]


:4.16. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; segments on the line, where segment &lt;math&gt;S_i&lt;/math&gt; ranges from &lt;math&gt;l_i&lt;/math&gt; to &lt;math&gt;r_i&lt;/math&gt;. Give an efficient algorithm to select the fewest number of segments whose union completely covers the interval from 0 to &lt;math&gt;m&lt;/math&gt;.

===Heaps===

:[[4.17]]


:4.18


:[[4.19]]


:4.20


===Quicksort===

:[[4.21]]


:4.22


:[[4.23]]


:4.24


:[[4.25]]


:4.26


:[[4.27]]


===Mergesort===

:4.28


:[[4.29]]


:4.30


===Other Sorting Alogrithims===

:[[4.31]]


:4.32


:[[4.33]]


:4.34


:[[4.35]]


:4.36


:[[4.37]]


:4.38


===Lower Bounds===

:[[4.39]]


:4.40


===Searching===

:[[4.41]]


:4.42


===Implementaion Challenges===

:[[4.43]]


:4.44


:[[4.45]]


:4.46

===Interview Problems===

:[[4.47]]


:4.48


:[[4.49]]


:4.50


:[[4.51]]


:4.52


:[[4.53]]


Back to [[Chapter List]]</text>
      <sha1>tja8ht9w05xl128rh34hwpg7eia0r0o</sha1>
    </revision>
    <revision>
      <id>270</id>
      <parentid>269</parentid>
      <timestamp>2020-09-19T19:39:59Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Heaps */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="9758">=Sorting=

===Applications of Sorting: Numbers===

:[[4.1]]. The Grinch is given the job of partitioning &lt;math&gt;2n&lt;/math&gt; players into two teams of &lt;math&gt;n&lt;/math&gt; players each. Each player has a numerical rating that measures how good he or she is at the game. The Grinch seeks to divide the players as ''unfairly'' as possible, so as to create the biggest possible talent imbalance between the teams. Show how the Grinch can do the job in &lt;math&gt;O(n log n)&lt;/math&gt; time.
[[4.1|Solution]]


:4.2. For each of the following problems, give an algorithm that finds the desired numbers within the given amount of time. To keep your answers brief, feel free to use algorithms from the book as subroutines. For the example, &lt;math&gt;S = {6, 13, 19, 3, 8}&lt;/math&gt;, 19 - 3 maximizes the difference, while 8 - 6 minimizes the difference.
:(a) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x-y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.
:(b) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x - y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(1)&lt;/math&gt; worst-case time.
:(c) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n log n)&lt;/math&gt; worst-case time.
:(d) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.


:[[4.3]]. Take a list of &lt;math&gt;2n&lt;/math&gt; real numbers as input. Design an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm that partitions the numbers into &lt;math&gt;n&lt;/math&gt; pairs, with the property that the partition minimizes the maximum sum of a pair. For example, say we are given the numbers (1,3,5,9). The possible partitions are ((1,3),(5,9)), ((1,5),(3,9)), and ((1,9),(3,5)). The pair sums for these partitions are (4,14), (6,12), and (10,8). Thus, the third partition has 10 as its maximum sum, which is the minimum over the three partitions.
[[4.3|Solution]]


:4.4. Assume that we are given &lt;math&gt;n&lt;/math&gt; pairs of items as input, where the first item is a number and the second item is one of three colors (red, blue, or yellow). Further assume that the items are sorted by number. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm to sort the items by color (all reds before all blues before all yellows) such that the numbers for identical colors stay sorted.
:For example: (1,blue), (3,red), (4,blue), (6,yellow), (9,red) should become (3,red), (9,red), (1,blue), (4,blue), (6,yellow).


:[[4.5]]. The ''mode'' of a bag of numbers is the number that occurs most frequently in the set. The set {4, 6, 2, 4, 3, 1} has a mode of 4. Give an efficient and correct algorithm to compute the mode of a bag of &lt;math&gt;n&lt;/math&gt; numbers.
[[4.5|Solution]]


:4.6. Given two sets &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt; (each of size &lt;math&gt;n&lt;/math&gt;), and a number &lt;math&gt;x&lt;/math&gt;, describe an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for finding whether there exists a pair of elements, one from &lt;math&gt;S_1&lt;/math&gt; and one from &lt;math&gt;S_2&lt;/math&gt;, that add up to &lt;math&gt;x&lt;/math&gt;. (For partial credit, give a &lt;math&gt;\Theta(n^2)&lt;/math&gt; algorithm for this problem.)


:[[4.7]]. Give an efficient algorithm to take the array of citation counts (each count is a non-negative integer) of a researcher’s papers, and compute the researcher’s &lt;math&gt;h&lt;/math&gt;-index. By definition, a scientist has index &lt;math&gt;h&lt;/math&gt; if &lt;math&gt;h&lt;/math&gt; of his or her &lt;math&gt;n&lt;/math&gt; papers have been cited at least &lt;math&gt;h&lt;/math&gt; times, while the other &lt;math&gt;n-h&lt;/math&gt; papers each have no more than &lt;math&gt;h&lt;/math&gt; citations.
[[4.7|Solution]]


:4.8. Outline a reasonable method of solving each of the following problems. Give the order of the worst-case complexity of your methods.
:(a) You are given a pile of thousands of telephone bills and thousands of checks sent in to pay the bills. Find out who did not pay.
:(b) You are given a printed list containing the title, author, call number, and publisher of all the books in a school library and another list of thirty publishers. Find out how many of the books in the library were published by each company.
:(c) You are given all the book checkout cards used in the campus library during the past year, each of which contains the name of the person who took out the book. Determine how many distinct people checked out at least one book.


:[[4.9]]. Given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers and an integer &lt;math&gt;T&lt;/math&gt;, give an &lt;math&gt;O(n^{k-1}log n)&lt;/math&gt; algorithm to test whether &lt;math&gt;k&lt;/math&gt; of the integers in &lt;math&gt;S&lt;/math&gt; add up to &lt;math&gt;T&lt;/math&gt;.
[[4.9|Solution]]


:4.10. We are given a set of &lt;math&gt;S&lt;/math&gt; containing &lt;math&gt;n&lt;/math&gt; real numbers and a real number &lt;math&gt;x&lt;/math&gt;, and seek efficient algorithms to determine whether two elements of &lt;math&gt;S&lt;/math&gt; exist whose sum is exactly &lt;math&gt;x&lt;/math&gt;.
:(a) Assume that &lt;math&gt;S&lt;/math&gt; is unsorted. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for the problem.
:(b) Assume that &lt;math&gt;S&lt;/math&gt; is sorted. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for the problem.


:[[4.11]]. Design an &lt;math&gt;O(n)&lt;/math&gt; algorithm that, given a list of &lt;math&gt;n&lt;/math&gt; elements, finds all the elements that appear more than &lt;math&gt;n/2&lt;/math&gt; times in the list. Then, design an &lt;math&gt;O(n)&lt;/math&gt; algorithm that, given a list of &lt;math&gt;n&lt;/math&gt; elements, finds all the elements that appear more than &lt;math&gt;n/4&lt;/math&gt; times.
[[4.11|Solution]]

===Applications of Sorting: Intervals and Sets===

:4.12. Give an efficient algorithm to compute the union of sets &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt;, where &lt;math&gt;n = max(|A|, |B|)&lt;/math&gt;. The output should be an array of distinct elements that form the union of the sets.
:(a) Assume that &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; are unsorted arrays. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for the problem.
:(b) Assume that &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; are sorted arrays. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for the problem.


:[[4.13]]. A camera at the door tracks the entry time &lt;math&gt;a_i&lt;/math&gt; and exit time &lt;math&gt;b_i&lt;/math&gt; (assume &lt;math&gt;b_i &gt; a_i&lt;/math&gt;) for each of &lt;math&gt;n&lt;/math&gt; persons &lt;math&gt;p_i&lt;/math&gt; attending a party. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm that analyzes this data to determine the time when the most people were simultaneously present at the party. You may assume that all entry and exit times are distinct (no ties).
[[4.13|Solution]]


:4.14. Given a list &lt;math&gt;I&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; intervals, specified as &lt;math&gt;(x_i, y_i)&lt;/math&gt; pairs, return a list where the overlapping intervals are merged. For &lt;math&gt;I = {(1, 3),(2, 6),(8, 10),(7, 18)}&lt;/math&gt; the output should be &lt;math&gt;{(1, 6),(7, 18)}&lt;/math&gt;. Your algorithm should run in worst-case &lt;math&gt;O(n log n)&lt;/math&gt; time complexity.


:[[4.15]]. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; intervals on a line, with the &lt;math&gt;i&lt;/math&gt;th interval described by its left and right endpoints &lt;math&gt;(l_i, r_i)&lt;/math&gt;. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm to identify a point &lt;math&gt;p&lt;/math&gt; on the line that is in the largest number of intervals.
:As an example, for &lt;math&gt;S = {(10, 40),(20, 60),(50, 90),(15, 70)}&lt;/math&gt; no point exists in all four intervals, but &lt;math&gt;p = 50&lt;/math&gt; is an example of a point in three intervals. You can assume an endpoint counts as being in its interval.
[[4.15|Solution]]


:4.16. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; segments on the line, where segment &lt;math&gt;S_i&lt;/math&gt; ranges from &lt;math&gt;l_i&lt;/math&gt; to &lt;math&gt;r_i&lt;/math&gt;. Give an efficient algorithm to select the fewest number of segments whose union completely covers the interval from 0 to &lt;math&gt;m&lt;/math&gt;.

===Heaps===

:[[4.17]]. Devise an algorithm for finding the &lt;math&gt;k&lt;/math&gt; smallest elements of an unsorted set of &lt;math&gt;n&lt;/math&gt; integers in &lt;math&gt;O(n + k log n)&lt;/math&gt;.
[[4.17|Solution]]


:4.18. Give an &lt;math&gt;O(n log k)&lt;/math&gt;-time algorithm that merges &lt;math&gt;k&lt;/math&gt; sorted lists with a total of &lt;math&gt;n&lt;/math&gt; elements into one sorted list. (Hint: use a heap to speed up the obvious &lt;math&gt;O(know)&lt;/math&gt;-time algorithm).


:[[4.19]]. You wish to store a set of &lt;math&gt;n&lt;/math&gt; numbers in either a max-heap or a sorted array. For each application below, state which data structure is better, or if it does not matter. Explain your answers.
:(a) Find the maximum element quickly.
:(b) Delete an element quickly.
:(c) Form the structure quickly.
:(d) Find the minimum element quickly.
[[4.19|Solution]]


:4.20. (a) Give an efficient algorithm to find the second-largest key among &lt;math&gt;n&lt;/math&gt; keys. You can do better than &lt;math&gt;2n - 3&lt;/math&gt; comparisons.
:(b) Then, give an efficient algorithm to find the third-largest key among &lt;math&gt;n&lt;/math&gt; keys. How many key comparisons does your algorithm do in the worst case? Must your algorithm determine which key is largest and second-largest in the process?

===Quicksort===

:[[4.21]]


:4.22


:[[4.23]]


:4.24


:[[4.25]]


:4.26


:[[4.27]]


===Mergesort===

:4.28


:[[4.29]]


:4.30


===Other Sorting Alogrithims===

:[[4.31]]


:4.32


:[[4.33]]


:4.34


:[[4.35]]


:4.36


:[[4.37]]


:4.38


===Lower Bounds===

:[[4.39]]


:4.40


===Searching===

:[[4.41]]


:4.42


===Implementaion Challenges===

:[[4.43]]


:4.44


:[[4.45]]


:4.46

===Interview Problems===

:[[4.47]]


:4.48


:[[4.49]]


:4.50


:[[4.51]]


:4.52


:[[4.53]]


Back to [[Chapter List]]</text>
      <sha1>92b42ot6fp86b4ewlt4wqpxnv7dubiw</sha1>
    </revision>
    <revision>
      <id>271</id>
      <parentid>270</parentid>
      <timestamp>2020-09-19T19:52:58Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Quicksort */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="12669">=Sorting=

===Applications of Sorting: Numbers===

:[[4.1]]. The Grinch is given the job of partitioning &lt;math&gt;2n&lt;/math&gt; players into two teams of &lt;math&gt;n&lt;/math&gt; players each. Each player has a numerical rating that measures how good he or she is at the game. The Grinch seeks to divide the players as ''unfairly'' as possible, so as to create the biggest possible talent imbalance between the teams. Show how the Grinch can do the job in &lt;math&gt;O(n log n)&lt;/math&gt; time.
[[4.1|Solution]]


:4.2. For each of the following problems, give an algorithm that finds the desired numbers within the given amount of time. To keep your answers brief, feel free to use algorithms from the book as subroutines. For the example, &lt;math&gt;S = {6, 13, 19, 3, 8}&lt;/math&gt;, 19 - 3 maximizes the difference, while 8 - 6 minimizes the difference.
:(a) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x-y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.
:(b) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x - y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(1)&lt;/math&gt; worst-case time.
:(c) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n log n)&lt;/math&gt; worst-case time.
:(d) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.


:[[4.3]]. Take a list of &lt;math&gt;2n&lt;/math&gt; real numbers as input. Design an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm that partitions the numbers into &lt;math&gt;n&lt;/math&gt; pairs, with the property that the partition minimizes the maximum sum of a pair. For example, say we are given the numbers (1,3,5,9). The possible partitions are ((1,3),(5,9)), ((1,5),(3,9)), and ((1,9),(3,5)). The pair sums for these partitions are (4,14), (6,12), and (10,8). Thus, the third partition has 10 as its maximum sum, which is the minimum over the three partitions.
[[4.3|Solution]]


:4.4. Assume that we are given &lt;math&gt;n&lt;/math&gt; pairs of items as input, where the first item is a number and the second item is one of three colors (red, blue, or yellow). Further assume that the items are sorted by number. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm to sort the items by color (all reds before all blues before all yellows) such that the numbers for identical colors stay sorted.
:For example: (1,blue), (3,red), (4,blue), (6,yellow), (9,red) should become (3,red), (9,red), (1,blue), (4,blue), (6,yellow).


:[[4.5]]. The ''mode'' of a bag of numbers is the number that occurs most frequently in the set. The set {4, 6, 2, 4, 3, 1} has a mode of 4. Give an efficient and correct algorithm to compute the mode of a bag of &lt;math&gt;n&lt;/math&gt; numbers.
[[4.5|Solution]]


:4.6. Given two sets &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt; (each of size &lt;math&gt;n&lt;/math&gt;), and a number &lt;math&gt;x&lt;/math&gt;, describe an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for finding whether there exists a pair of elements, one from &lt;math&gt;S_1&lt;/math&gt; and one from &lt;math&gt;S_2&lt;/math&gt;, that add up to &lt;math&gt;x&lt;/math&gt;. (For partial credit, give a &lt;math&gt;\Theta(n^2)&lt;/math&gt; algorithm for this problem.)


:[[4.7]]. Give an efficient algorithm to take the array of citation counts (each count is a non-negative integer) of a researcher’s papers, and compute the researcher’s &lt;math&gt;h&lt;/math&gt;-index. By definition, a scientist has index &lt;math&gt;h&lt;/math&gt; if &lt;math&gt;h&lt;/math&gt; of his or her &lt;math&gt;n&lt;/math&gt; papers have been cited at least &lt;math&gt;h&lt;/math&gt; times, while the other &lt;math&gt;n-h&lt;/math&gt; papers each have no more than &lt;math&gt;h&lt;/math&gt; citations.
[[4.7|Solution]]


:4.8. Outline a reasonable method of solving each of the following problems. Give the order of the worst-case complexity of your methods.
:(a) You are given a pile of thousands of telephone bills and thousands of checks sent in to pay the bills. Find out who did not pay.
:(b) You are given a printed list containing the title, author, call number, and publisher of all the books in a school library and another list of thirty publishers. Find out how many of the books in the library were published by each company.
:(c) You are given all the book checkout cards used in the campus library during the past year, each of which contains the name of the person who took out the book. Determine how many distinct people checked out at least one book.


:[[4.9]]. Given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers and an integer &lt;math&gt;T&lt;/math&gt;, give an &lt;math&gt;O(n^{k-1}log n)&lt;/math&gt; algorithm to test whether &lt;math&gt;k&lt;/math&gt; of the integers in &lt;math&gt;S&lt;/math&gt; add up to &lt;math&gt;T&lt;/math&gt;.
[[4.9|Solution]]


:4.10. We are given a set of &lt;math&gt;S&lt;/math&gt; containing &lt;math&gt;n&lt;/math&gt; real numbers and a real number &lt;math&gt;x&lt;/math&gt;, and seek efficient algorithms to determine whether two elements of &lt;math&gt;S&lt;/math&gt; exist whose sum is exactly &lt;math&gt;x&lt;/math&gt;.
:(a) Assume that &lt;math&gt;S&lt;/math&gt; is unsorted. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for the problem.
:(b) Assume that &lt;math&gt;S&lt;/math&gt; is sorted. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for the problem.


:[[4.11]]. Design an &lt;math&gt;O(n)&lt;/math&gt; algorithm that, given a list of &lt;math&gt;n&lt;/math&gt; elements, finds all the elements that appear more than &lt;math&gt;n/2&lt;/math&gt; times in the list. Then, design an &lt;math&gt;O(n)&lt;/math&gt; algorithm that, given a list of &lt;math&gt;n&lt;/math&gt; elements, finds all the elements that appear more than &lt;math&gt;n/4&lt;/math&gt; times.
[[4.11|Solution]]

===Applications of Sorting: Intervals and Sets===

:4.12. Give an efficient algorithm to compute the union of sets &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt;, where &lt;math&gt;n = max(|A|, |B|)&lt;/math&gt;. The output should be an array of distinct elements that form the union of the sets.
:(a) Assume that &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; are unsorted arrays. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for the problem.
:(b) Assume that &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; are sorted arrays. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for the problem.


:[[4.13]]. A camera at the door tracks the entry time &lt;math&gt;a_i&lt;/math&gt; and exit time &lt;math&gt;b_i&lt;/math&gt; (assume &lt;math&gt;b_i &gt; a_i&lt;/math&gt;) for each of &lt;math&gt;n&lt;/math&gt; persons &lt;math&gt;p_i&lt;/math&gt; attending a party. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm that analyzes this data to determine the time when the most people were simultaneously present at the party. You may assume that all entry and exit times are distinct (no ties).
[[4.13|Solution]]


:4.14. Given a list &lt;math&gt;I&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; intervals, specified as &lt;math&gt;(x_i, y_i)&lt;/math&gt; pairs, return a list where the overlapping intervals are merged. For &lt;math&gt;I = {(1, 3),(2, 6),(8, 10),(7, 18)}&lt;/math&gt; the output should be &lt;math&gt;{(1, 6),(7, 18)}&lt;/math&gt;. Your algorithm should run in worst-case &lt;math&gt;O(n log n)&lt;/math&gt; time complexity.


:[[4.15]]. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; intervals on a line, with the &lt;math&gt;i&lt;/math&gt;th interval described by its left and right endpoints &lt;math&gt;(l_i, r_i)&lt;/math&gt;. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm to identify a point &lt;math&gt;p&lt;/math&gt; on the line that is in the largest number of intervals.
:As an example, for &lt;math&gt;S = {(10, 40),(20, 60),(50, 90),(15, 70)}&lt;/math&gt; no point exists in all four intervals, but &lt;math&gt;p = 50&lt;/math&gt; is an example of a point in three intervals. You can assume an endpoint counts as being in its interval.
[[4.15|Solution]]


:4.16. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; segments on the line, where segment &lt;math&gt;S_i&lt;/math&gt; ranges from &lt;math&gt;l_i&lt;/math&gt; to &lt;math&gt;r_i&lt;/math&gt;. Give an efficient algorithm to select the fewest number of segments whose union completely covers the interval from 0 to &lt;math&gt;m&lt;/math&gt;.

===Heaps===

:[[4.17]]. Devise an algorithm for finding the &lt;math&gt;k&lt;/math&gt; smallest elements of an unsorted set of &lt;math&gt;n&lt;/math&gt; integers in &lt;math&gt;O(n + k log n)&lt;/math&gt;.
[[4.17|Solution]]


:4.18. Give an &lt;math&gt;O(n log k)&lt;/math&gt;-time algorithm that merges &lt;math&gt;k&lt;/math&gt; sorted lists with a total of &lt;math&gt;n&lt;/math&gt; elements into one sorted list. (Hint: use a heap to speed up the obvious &lt;math&gt;O(know)&lt;/math&gt;-time algorithm).


:[[4.19]]. You wish to store a set of &lt;math&gt;n&lt;/math&gt; numbers in either a max-heap or a sorted array. For each application below, state which data structure is better, or if it does not matter. Explain your answers.
:(a) Find the maximum element quickly.
:(b) Delete an element quickly.
:(c) Form the structure quickly.
:(d) Find the minimum element quickly.
[[4.19|Solution]]


:4.20. (a) Give an efficient algorithm to find the second-largest key among &lt;math&gt;n&lt;/math&gt; keys. You can do better than &lt;math&gt;2n - 3&lt;/math&gt; comparisons.
:(b) Then, give an efficient algorithm to find the third-largest key among &lt;math&gt;n&lt;/math&gt; keys. How many key comparisons does your algorithm do in the worst case? Must your algorithm determine which key is largest and second-largest in the process?

===Quicksort===

:[[4.21]]. Use the partitioning idea of quicksort to give an algorithm that finds the median element of an array of &lt;math&gt;n&lt;/math&gt; integers in expected &lt;math&gt;O(n)&lt;/math&gt; time. (Hint: must you look at both sides of the partition?)
[[4.21|Solution]]


:4.22. The ''median'' of a set of &lt;math&gt;n&lt;/math&gt; values is the &lt;math&gt;[n/2]&lt;/math&gt;th smallest value.
:(a) Suppose quicksort always pivoted on the median of the current sub-array. How many comparisons would quicksort make then in the worst case?
:(b) Suppose quicksort always pivoted on the &lt;math&gt;[n/3]&lt;/math&gt;th smallest value of the current sub-array. How many comparisons would be made then in the worst case?


:[[4.23]]. Suppose an array &lt;math&gt;A&lt;/math&gt; consists of &lt;math&gt;n&lt;/math&gt; elements, each of which is ''red'', ''white'', or ''blue'. We seek to sort the elements so that all the ''reds'' come before all the ''whites'', which come before all the ''blues''. The only operations permitted on the keys are:
::• ''Examine''(&lt;math&gt;A,i&lt;/math&gt;) – report the color of the &lt;math&gt;i&lt;/math&gt;th element of &lt;math&gt;A&lt;/math&gt;.
::• ''Swap''(&lt;math&gt;A,i,j&lt;/math&gt;) – swap the &lt;math&gt;i&lt;/math&gt;th element of &lt;math&gt;A&lt;/math&gt; with the &lt;math&gt;j&lt;/math&gt;th element.
:Find a correct and efficient algorithm for red–white–blue sorting. There is a linear-time solution.
[[4.23|Solution]]


:4.24. Give an efficient algorithm to rearrange an array of &lt;math&gt;n&lt;/math&gt; keys so that all the negative keys precede all the non-negative keys. Your algorithm must be in-place, meaning you cannot allocate another array to temporarily hold the items. How fast is your algorithm?


:[[4.25]]. Consider a given pair of different elements in an input array to be sorted, say &lt;math&gt;z_i&lt;/math&gt; and &lt;math&gt;z_j&lt;/math&gt; . What is the most number of times &lt;math&gt;z_i&lt;/math&gt; and &lt;math&gt;z_j&lt;/math&gt; might be compared with each other during an execution of quicksort?
[[4.25|Solution]]


:4.26. Define the recursion depth of quicksort as the maximum number of successive recursive calls it makes before hitting the base case. What are the minimum and maximum possible recursion depths for randomized quicksort?


:[[4.27]]. Suppose you are given a permutation &lt;math&gt;p&lt;/math&gt; of the integers 1 to &lt;math&gt;n&lt;/math&gt;, and seek to sort them to be in increasing order &lt;math&gt;[1, . . . , n]&lt;/math&gt;. The only operation at your disposal is ''reverse''&lt;math&gt;(p,i,j)&lt;/math&gt;, which reverses the elements of a subsequence &lt;math&gt;p_i, . . . , p_j&lt;/math&gt; in the permutation. For the permutation [1, 4, 3, 2, 5] one reversal (of the second through fourth elements) suffices to sort.
:• Show that it is possible to sort any permutation using &lt;math&gt;O(n)&lt;/math&gt; reversals.
:• Now suppose that the cost of ''reverse''&lt;math&gt;(p,i,j)&lt;/math&gt; is equal to its length, the number of elements in the range, &lt;math&gt;|j - i| + 1&lt;/math&gt;. Design an algorithm that sorts &lt;math&gt;p&lt;/math&gt; in &lt;math&gt;O(n log^2 n)&lt;/math&gt; cost. Analyze the running time and cost of your algorithm and prove correctness.
[[4.27|Solution]]

===Mergesort===

:4.28


:[[4.29]]


:4.30


===Other Sorting Alogrithims===

:[[4.31]]


:4.32


:[[4.33]]


:4.34


:[[4.35]]


:4.36


:[[4.37]]


:4.38


===Lower Bounds===

:[[4.39]]


:4.40


===Searching===

:[[4.41]]


:4.42


===Implementaion Challenges===

:[[4.43]]


:4.44


:[[4.45]]


:4.46

===Interview Problems===

:[[4.47]]


:4.48


:[[4.49]]


:4.50


:[[4.51]]


:4.52


:[[4.53]]


Back to [[Chapter List]]</text>
      <sha1>es5uyiv2bxtkxhmd553h1eeraikpp47</sha1>
    </revision>
    <revision>
      <id>272</id>
      <parentid>271</parentid>
      <timestamp>2020-09-19T19:58:10Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Mergesort */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="13929">=Sorting=

===Applications of Sorting: Numbers===

:[[4.1]]. The Grinch is given the job of partitioning &lt;math&gt;2n&lt;/math&gt; players into two teams of &lt;math&gt;n&lt;/math&gt; players each. Each player has a numerical rating that measures how good he or she is at the game. The Grinch seeks to divide the players as ''unfairly'' as possible, so as to create the biggest possible talent imbalance between the teams. Show how the Grinch can do the job in &lt;math&gt;O(n log n)&lt;/math&gt; time.
[[4.1|Solution]]


:4.2. For each of the following problems, give an algorithm that finds the desired numbers within the given amount of time. To keep your answers brief, feel free to use algorithms from the book as subroutines. For the example, &lt;math&gt;S = {6, 13, 19, 3, 8}&lt;/math&gt;, 19 - 3 maximizes the difference, while 8 - 6 minimizes the difference.
:(a) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x-y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.
:(b) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x - y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(1)&lt;/math&gt; worst-case time.
:(c) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n log n)&lt;/math&gt; worst-case time.
:(d) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.


:[[4.3]]. Take a list of &lt;math&gt;2n&lt;/math&gt; real numbers as input. Design an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm that partitions the numbers into &lt;math&gt;n&lt;/math&gt; pairs, with the property that the partition minimizes the maximum sum of a pair. For example, say we are given the numbers (1,3,5,9). The possible partitions are ((1,3),(5,9)), ((1,5),(3,9)), and ((1,9),(3,5)). The pair sums for these partitions are (4,14), (6,12), and (10,8). Thus, the third partition has 10 as its maximum sum, which is the minimum over the three partitions.
[[4.3|Solution]]


:4.4. Assume that we are given &lt;math&gt;n&lt;/math&gt; pairs of items as input, where the first item is a number and the second item is one of three colors (red, blue, or yellow). Further assume that the items are sorted by number. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm to sort the items by color (all reds before all blues before all yellows) such that the numbers for identical colors stay sorted.
:For example: (1,blue), (3,red), (4,blue), (6,yellow), (9,red) should become (3,red), (9,red), (1,blue), (4,blue), (6,yellow).


:[[4.5]]. The ''mode'' of a bag of numbers is the number that occurs most frequently in the set. The set {4, 6, 2, 4, 3, 1} has a mode of 4. Give an efficient and correct algorithm to compute the mode of a bag of &lt;math&gt;n&lt;/math&gt; numbers.
[[4.5|Solution]]


:4.6. Given two sets &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt; (each of size &lt;math&gt;n&lt;/math&gt;), and a number &lt;math&gt;x&lt;/math&gt;, describe an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for finding whether there exists a pair of elements, one from &lt;math&gt;S_1&lt;/math&gt; and one from &lt;math&gt;S_2&lt;/math&gt;, that add up to &lt;math&gt;x&lt;/math&gt;. (For partial credit, give a &lt;math&gt;\Theta(n^2)&lt;/math&gt; algorithm for this problem.)


:[[4.7]]. Give an efficient algorithm to take the array of citation counts (each count is a non-negative integer) of a researcher’s papers, and compute the researcher’s &lt;math&gt;h&lt;/math&gt;-index. By definition, a scientist has index &lt;math&gt;h&lt;/math&gt; if &lt;math&gt;h&lt;/math&gt; of his or her &lt;math&gt;n&lt;/math&gt; papers have been cited at least &lt;math&gt;h&lt;/math&gt; times, while the other &lt;math&gt;n-h&lt;/math&gt; papers each have no more than &lt;math&gt;h&lt;/math&gt; citations.
[[4.7|Solution]]


:4.8. Outline a reasonable method of solving each of the following problems. Give the order of the worst-case complexity of your methods.
:(a) You are given a pile of thousands of telephone bills and thousands of checks sent in to pay the bills. Find out who did not pay.
:(b) You are given a printed list containing the title, author, call number, and publisher of all the books in a school library and another list of thirty publishers. Find out how many of the books in the library were published by each company.
:(c) You are given all the book checkout cards used in the campus library during the past year, each of which contains the name of the person who took out the book. Determine how many distinct people checked out at least one book.


:[[4.9]]. Given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers and an integer &lt;math&gt;T&lt;/math&gt;, give an &lt;math&gt;O(n^{k-1}log n)&lt;/math&gt; algorithm to test whether &lt;math&gt;k&lt;/math&gt; of the integers in &lt;math&gt;S&lt;/math&gt; add up to &lt;math&gt;T&lt;/math&gt;.
[[4.9|Solution]]


:4.10. We are given a set of &lt;math&gt;S&lt;/math&gt; containing &lt;math&gt;n&lt;/math&gt; real numbers and a real number &lt;math&gt;x&lt;/math&gt;, and seek efficient algorithms to determine whether two elements of &lt;math&gt;S&lt;/math&gt; exist whose sum is exactly &lt;math&gt;x&lt;/math&gt;.
:(a) Assume that &lt;math&gt;S&lt;/math&gt; is unsorted. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for the problem.
:(b) Assume that &lt;math&gt;S&lt;/math&gt; is sorted. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for the problem.


:[[4.11]]. Design an &lt;math&gt;O(n)&lt;/math&gt; algorithm that, given a list of &lt;math&gt;n&lt;/math&gt; elements, finds all the elements that appear more than &lt;math&gt;n/2&lt;/math&gt; times in the list. Then, design an &lt;math&gt;O(n)&lt;/math&gt; algorithm that, given a list of &lt;math&gt;n&lt;/math&gt; elements, finds all the elements that appear more than &lt;math&gt;n/4&lt;/math&gt; times.
[[4.11|Solution]]

===Applications of Sorting: Intervals and Sets===

:4.12. Give an efficient algorithm to compute the union of sets &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt;, where &lt;math&gt;n = max(|A|, |B|)&lt;/math&gt;. The output should be an array of distinct elements that form the union of the sets.
:(a) Assume that &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; are unsorted arrays. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for the problem.
:(b) Assume that &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; are sorted arrays. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for the problem.


:[[4.13]]. A camera at the door tracks the entry time &lt;math&gt;a_i&lt;/math&gt; and exit time &lt;math&gt;b_i&lt;/math&gt; (assume &lt;math&gt;b_i &gt; a_i&lt;/math&gt;) for each of &lt;math&gt;n&lt;/math&gt; persons &lt;math&gt;p_i&lt;/math&gt; attending a party. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm that analyzes this data to determine the time when the most people were simultaneously present at the party. You may assume that all entry and exit times are distinct (no ties).
[[4.13|Solution]]


:4.14. Given a list &lt;math&gt;I&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; intervals, specified as &lt;math&gt;(x_i, y_i)&lt;/math&gt; pairs, return a list where the overlapping intervals are merged. For &lt;math&gt;I = {(1, 3),(2, 6),(8, 10),(7, 18)}&lt;/math&gt; the output should be &lt;math&gt;{(1, 6),(7, 18)}&lt;/math&gt;. Your algorithm should run in worst-case &lt;math&gt;O(n log n)&lt;/math&gt; time complexity.


:[[4.15]]. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; intervals on a line, with the &lt;math&gt;i&lt;/math&gt;th interval described by its left and right endpoints &lt;math&gt;(l_i, r_i)&lt;/math&gt;. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm to identify a point &lt;math&gt;p&lt;/math&gt; on the line that is in the largest number of intervals.
:As an example, for &lt;math&gt;S = {(10, 40),(20, 60),(50, 90),(15, 70)}&lt;/math&gt; no point exists in all four intervals, but &lt;math&gt;p = 50&lt;/math&gt; is an example of a point in three intervals. You can assume an endpoint counts as being in its interval.
[[4.15|Solution]]


:4.16. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; segments on the line, where segment &lt;math&gt;S_i&lt;/math&gt; ranges from &lt;math&gt;l_i&lt;/math&gt; to &lt;math&gt;r_i&lt;/math&gt;. Give an efficient algorithm to select the fewest number of segments whose union completely covers the interval from 0 to &lt;math&gt;m&lt;/math&gt;.

===Heaps===

:[[4.17]]. Devise an algorithm for finding the &lt;math&gt;k&lt;/math&gt; smallest elements of an unsorted set of &lt;math&gt;n&lt;/math&gt; integers in &lt;math&gt;O(n + k log n)&lt;/math&gt;.
[[4.17|Solution]]


:4.18. Give an &lt;math&gt;O(n log k)&lt;/math&gt;-time algorithm that merges &lt;math&gt;k&lt;/math&gt; sorted lists with a total of &lt;math&gt;n&lt;/math&gt; elements into one sorted list. (Hint: use a heap to speed up the obvious &lt;math&gt;O(know)&lt;/math&gt;-time algorithm).


:[[4.19]]. You wish to store a set of &lt;math&gt;n&lt;/math&gt; numbers in either a max-heap or a sorted array. For each application below, state which data structure is better, or if it does not matter. Explain your answers.
:(a) Find the maximum element quickly.
:(b) Delete an element quickly.
:(c) Form the structure quickly.
:(d) Find the minimum element quickly.
[[4.19|Solution]]


:4.20. (a) Give an efficient algorithm to find the second-largest key among &lt;math&gt;n&lt;/math&gt; keys. You can do better than &lt;math&gt;2n - 3&lt;/math&gt; comparisons.
:(b) Then, give an efficient algorithm to find the third-largest key among &lt;math&gt;n&lt;/math&gt; keys. How many key comparisons does your algorithm do in the worst case? Must your algorithm determine which key is largest and second-largest in the process?

===Quicksort===

:[[4.21]]. Use the partitioning idea of quicksort to give an algorithm that finds the median element of an array of &lt;math&gt;n&lt;/math&gt; integers in expected &lt;math&gt;O(n)&lt;/math&gt; time. (Hint: must you look at both sides of the partition?)
[[4.21|Solution]]


:4.22. The ''median'' of a set of &lt;math&gt;n&lt;/math&gt; values is the &lt;math&gt;[n/2]&lt;/math&gt;th smallest value.
:(a) Suppose quicksort always pivoted on the median of the current sub-array. How many comparisons would quicksort make then in the worst case?
:(b) Suppose quicksort always pivoted on the &lt;math&gt;[n/3]&lt;/math&gt;th smallest value of the current sub-array. How many comparisons would be made then in the worst case?


:[[4.23]]. Suppose an array &lt;math&gt;A&lt;/math&gt; consists of &lt;math&gt;n&lt;/math&gt; elements, each of which is ''red'', ''white'', or ''blue'. We seek to sort the elements so that all the ''reds'' come before all the ''whites'', which come before all the ''blues''. The only operations permitted on the keys are:
::• ''Examine''(&lt;math&gt;A,i&lt;/math&gt;) – report the color of the &lt;math&gt;i&lt;/math&gt;th element of &lt;math&gt;A&lt;/math&gt;.
::• ''Swap''(&lt;math&gt;A,i,j&lt;/math&gt;) – swap the &lt;math&gt;i&lt;/math&gt;th element of &lt;math&gt;A&lt;/math&gt; with the &lt;math&gt;j&lt;/math&gt;th element.
:Find a correct and efficient algorithm for red–white–blue sorting. There is a linear-time solution.
[[4.23|Solution]]


:4.24. Give an efficient algorithm to rearrange an array of &lt;math&gt;n&lt;/math&gt; keys so that all the negative keys precede all the non-negative keys. Your algorithm must be in-place, meaning you cannot allocate another array to temporarily hold the items. How fast is your algorithm?


:[[4.25]]. Consider a given pair of different elements in an input array to be sorted, say &lt;math&gt;z_i&lt;/math&gt; and &lt;math&gt;z_j&lt;/math&gt; . What is the most number of times &lt;math&gt;z_i&lt;/math&gt; and &lt;math&gt;z_j&lt;/math&gt; might be compared with each other during an execution of quicksort?
[[4.25|Solution]]


:4.26. Define the recursion depth of quicksort as the maximum number of successive recursive calls it makes before hitting the base case. What are the minimum and maximum possible recursion depths for randomized quicksort?


:[[4.27]]. Suppose you are given a permutation &lt;math&gt;p&lt;/math&gt; of the integers 1 to &lt;math&gt;n&lt;/math&gt;, and seek to sort them to be in increasing order &lt;math&gt;[1, . . . , n]&lt;/math&gt;. The only operation at your disposal is ''reverse''&lt;math&gt;(p,i,j)&lt;/math&gt;, which reverses the elements of a subsequence &lt;math&gt;p_i, . . . , p_j&lt;/math&gt; in the permutation. For the permutation [1, 4, 3, 2, 5] one reversal (of the second through fourth elements) suffices to sort.
:• Show that it is possible to sort any permutation using &lt;math&gt;O(n)&lt;/math&gt; reversals.
:• Now suppose that the cost of ''reverse''&lt;math&gt;(p,i,j)&lt;/math&gt; is equal to its length, the number of elements in the range, &lt;math&gt;|j - i| + 1&lt;/math&gt;. Design an algorithm that sorts &lt;math&gt;p&lt;/math&gt; in &lt;math&gt;O(n log^2 n)&lt;/math&gt; cost. Analyze the running time and cost of your algorithm and prove correctness.
[[4.27|Solution]]

===Mergesort===

:4.28. Consider the following modification to merge sort: divide the input array into thirds (rather than halves), recursively sort each third, and finally combine the results using a three-way merge subroutine. What is the worst-case running time of this modified merge sort?


:[[4.29]]. Suppose you are given &lt;math&gt;k&lt;/math&gt; sorted arrays, each with &lt;math&gt;n&lt;/math&gt; elements, and you want to combine them into a single sorted array of &lt;math&gt;kn&lt;/math&gt; elements. One approach is to use the merge subroutine repeatedly, merging the first two arrays, then merging the result with the third array, then with the fourth array, and so on until you merge in the &lt;math&gt;k&lt;/math&gt;th and final input array. What is the running time?
[[4.29|Solution]]


:4.30. Consider again the problem of merging &lt;math&gt;k&lt;/math&gt; sorted length-&lt;math&gt;n&lt;/math&gt; arrays into a single sorted length-&lt;math&gt;kn&lt;/math&gt; array. Consider the algorithm that first divides the &lt;math&gt;k&lt;/math&gt; arrays into &lt;math&gt;k/2&lt;/math&gt; pairs of arrays, and uses the merge subroutine to combine each pair, resulting in &lt;math&gt;k/2&lt;/math&gt; sorted length-&lt;math&gt;2n&lt;/math&gt; arrays. The algorithm repeats this step until there is only one length-&lt;math&gt;know&lt;/math&gt; sorted array. What is the running time as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;?

===Other Sorting Alogrithims===

:[[4.31]]


:4.32


:[[4.33]]


:4.34


:[[4.35]]


:4.36


:[[4.37]]


:4.38


===Lower Bounds===

:[[4.39]]


:4.40


===Searching===

:[[4.41]]


:4.42


===Implementaion Challenges===

:[[4.43]]


:4.44


:[[4.45]]


:4.46

===Interview Problems===

:[[4.47]]


:4.48


:[[4.49]]


:4.50


:[[4.51]]


:4.52


:[[4.53]]


Back to [[Chapter List]]</text>
      <sha1>fhft1hqhu9kwu4ck6pdj68108vz46u1</sha1>
    </revision>
    <revision>
      <id>273</id>
      <parentid>272</parentid>
      <timestamp>2020-09-19T20:34:16Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Other Sorting Alogrithims */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="16600">=Sorting=

===Applications of Sorting: Numbers===

:[[4.1]]. The Grinch is given the job of partitioning &lt;math&gt;2n&lt;/math&gt; players into two teams of &lt;math&gt;n&lt;/math&gt; players each. Each player has a numerical rating that measures how good he or she is at the game. The Grinch seeks to divide the players as ''unfairly'' as possible, so as to create the biggest possible talent imbalance between the teams. Show how the Grinch can do the job in &lt;math&gt;O(n log n)&lt;/math&gt; time.
[[4.1|Solution]]


:4.2. For each of the following problems, give an algorithm that finds the desired numbers within the given amount of time. To keep your answers brief, feel free to use algorithms from the book as subroutines. For the example, &lt;math&gt;S = {6, 13, 19, 3, 8}&lt;/math&gt;, 19 - 3 maximizes the difference, while 8 - 6 minimizes the difference.
:(a) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x-y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.
:(b) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x - y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(1)&lt;/math&gt; worst-case time.
:(c) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n log n)&lt;/math&gt; worst-case time.
:(d) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.


:[[4.3]]. Take a list of &lt;math&gt;2n&lt;/math&gt; real numbers as input. Design an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm that partitions the numbers into &lt;math&gt;n&lt;/math&gt; pairs, with the property that the partition minimizes the maximum sum of a pair. For example, say we are given the numbers (1,3,5,9). The possible partitions are ((1,3),(5,9)), ((1,5),(3,9)), and ((1,9),(3,5)). The pair sums for these partitions are (4,14), (6,12), and (10,8). Thus, the third partition has 10 as its maximum sum, which is the minimum over the three partitions.
[[4.3|Solution]]


:4.4. Assume that we are given &lt;math&gt;n&lt;/math&gt; pairs of items as input, where the first item is a number and the second item is one of three colors (red, blue, or yellow). Further assume that the items are sorted by number. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm to sort the items by color (all reds before all blues before all yellows) such that the numbers for identical colors stay sorted.
:For example: (1,blue), (3,red), (4,blue), (6,yellow), (9,red) should become (3,red), (9,red), (1,blue), (4,blue), (6,yellow).


:[[4.5]]. The ''mode'' of a bag of numbers is the number that occurs most frequently in the set. The set {4, 6, 2, 4, 3, 1} has a mode of 4. Give an efficient and correct algorithm to compute the mode of a bag of &lt;math&gt;n&lt;/math&gt; numbers.
[[4.5|Solution]]


:4.6. Given two sets &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt; (each of size &lt;math&gt;n&lt;/math&gt;), and a number &lt;math&gt;x&lt;/math&gt;, describe an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for finding whether there exists a pair of elements, one from &lt;math&gt;S_1&lt;/math&gt; and one from &lt;math&gt;S_2&lt;/math&gt;, that add up to &lt;math&gt;x&lt;/math&gt;. (For partial credit, give a &lt;math&gt;\Theta(n^2)&lt;/math&gt; algorithm for this problem.)


:[[4.7]]. Give an efficient algorithm to take the array of citation counts (each count is a non-negative integer) of a researcher’s papers, and compute the researcher’s &lt;math&gt;h&lt;/math&gt;-index. By definition, a scientist has index &lt;math&gt;h&lt;/math&gt; if &lt;math&gt;h&lt;/math&gt; of his or her &lt;math&gt;n&lt;/math&gt; papers have been cited at least &lt;math&gt;h&lt;/math&gt; times, while the other &lt;math&gt;n-h&lt;/math&gt; papers each have no more than &lt;math&gt;h&lt;/math&gt; citations.
[[4.7|Solution]]


:4.8. Outline a reasonable method of solving each of the following problems. Give the order of the worst-case complexity of your methods.
:(a) You are given a pile of thousands of telephone bills and thousands of checks sent in to pay the bills. Find out who did not pay.
:(b) You are given a printed list containing the title, author, call number, and publisher of all the books in a school library and another list of thirty publishers. Find out how many of the books in the library were published by each company.
:(c) You are given all the book checkout cards used in the campus library during the past year, each of which contains the name of the person who took out the book. Determine how many distinct people checked out at least one book.


:[[4.9]]. Given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers and an integer &lt;math&gt;T&lt;/math&gt;, give an &lt;math&gt;O(n^{k-1}log n)&lt;/math&gt; algorithm to test whether &lt;math&gt;k&lt;/math&gt; of the integers in &lt;math&gt;S&lt;/math&gt; add up to &lt;math&gt;T&lt;/math&gt;.
[[4.9|Solution]]


:4.10. We are given a set of &lt;math&gt;S&lt;/math&gt; containing &lt;math&gt;n&lt;/math&gt; real numbers and a real number &lt;math&gt;x&lt;/math&gt;, and seek efficient algorithms to determine whether two elements of &lt;math&gt;S&lt;/math&gt; exist whose sum is exactly &lt;math&gt;x&lt;/math&gt;.
:(a) Assume that &lt;math&gt;S&lt;/math&gt; is unsorted. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for the problem.
:(b) Assume that &lt;math&gt;S&lt;/math&gt; is sorted. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for the problem.


:[[4.11]]. Design an &lt;math&gt;O(n)&lt;/math&gt; algorithm that, given a list of &lt;math&gt;n&lt;/math&gt; elements, finds all the elements that appear more than &lt;math&gt;n/2&lt;/math&gt; times in the list. Then, design an &lt;math&gt;O(n)&lt;/math&gt; algorithm that, given a list of &lt;math&gt;n&lt;/math&gt; elements, finds all the elements that appear more than &lt;math&gt;n/4&lt;/math&gt; times.
[[4.11|Solution]]

===Applications of Sorting: Intervals and Sets===

:4.12. Give an efficient algorithm to compute the union of sets &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt;, where &lt;math&gt;n = max(|A|, |B|)&lt;/math&gt;. The output should be an array of distinct elements that form the union of the sets.
:(a) Assume that &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; are unsorted arrays. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for the problem.
:(b) Assume that &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; are sorted arrays. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for the problem.


:[[4.13]]. A camera at the door tracks the entry time &lt;math&gt;a_i&lt;/math&gt; and exit time &lt;math&gt;b_i&lt;/math&gt; (assume &lt;math&gt;b_i &gt; a_i&lt;/math&gt;) for each of &lt;math&gt;n&lt;/math&gt; persons &lt;math&gt;p_i&lt;/math&gt; attending a party. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm that analyzes this data to determine the time when the most people were simultaneously present at the party. You may assume that all entry and exit times are distinct (no ties).
[[4.13|Solution]]


:4.14. Given a list &lt;math&gt;I&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; intervals, specified as &lt;math&gt;(x_i, y_i)&lt;/math&gt; pairs, return a list where the overlapping intervals are merged. For &lt;math&gt;I = {(1, 3),(2, 6),(8, 10),(7, 18)}&lt;/math&gt; the output should be &lt;math&gt;{(1, 6),(7, 18)}&lt;/math&gt;. Your algorithm should run in worst-case &lt;math&gt;O(n log n)&lt;/math&gt; time complexity.


:[[4.15]]. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; intervals on a line, with the &lt;math&gt;i&lt;/math&gt;th interval described by its left and right endpoints &lt;math&gt;(l_i, r_i)&lt;/math&gt;. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm to identify a point &lt;math&gt;p&lt;/math&gt; on the line that is in the largest number of intervals.
:As an example, for &lt;math&gt;S = {(10, 40),(20, 60),(50, 90),(15, 70)}&lt;/math&gt; no point exists in all four intervals, but &lt;math&gt;p = 50&lt;/math&gt; is an example of a point in three intervals. You can assume an endpoint counts as being in its interval.
[[4.15|Solution]]


:4.16. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; segments on the line, where segment &lt;math&gt;S_i&lt;/math&gt; ranges from &lt;math&gt;l_i&lt;/math&gt; to &lt;math&gt;r_i&lt;/math&gt;. Give an efficient algorithm to select the fewest number of segments whose union completely covers the interval from 0 to &lt;math&gt;m&lt;/math&gt;.

===Heaps===

:[[4.17]]. Devise an algorithm for finding the &lt;math&gt;k&lt;/math&gt; smallest elements of an unsorted set of &lt;math&gt;n&lt;/math&gt; integers in &lt;math&gt;O(n + k log n)&lt;/math&gt;.
[[4.17|Solution]]


:4.18. Give an &lt;math&gt;O(n log k)&lt;/math&gt;-time algorithm that merges &lt;math&gt;k&lt;/math&gt; sorted lists with a total of &lt;math&gt;n&lt;/math&gt; elements into one sorted list. (Hint: use a heap to speed up the obvious &lt;math&gt;O(know)&lt;/math&gt;-time algorithm).


:[[4.19]]. You wish to store a set of &lt;math&gt;n&lt;/math&gt; numbers in either a max-heap or a sorted array. For each application below, state which data structure is better, or if it does not matter. Explain your answers.
:(a) Find the maximum element quickly.
:(b) Delete an element quickly.
:(c) Form the structure quickly.
:(d) Find the minimum element quickly.
[[4.19|Solution]]


:4.20. (a) Give an efficient algorithm to find the second-largest key among &lt;math&gt;n&lt;/math&gt; keys. You can do better than &lt;math&gt;2n - 3&lt;/math&gt; comparisons.
:(b) Then, give an efficient algorithm to find the third-largest key among &lt;math&gt;n&lt;/math&gt; keys. How many key comparisons does your algorithm do in the worst case? Must your algorithm determine which key is largest and second-largest in the process?

===Quicksort===

:[[4.21]]. Use the partitioning idea of quicksort to give an algorithm that finds the median element of an array of &lt;math&gt;n&lt;/math&gt; integers in expected &lt;math&gt;O(n)&lt;/math&gt; time. (Hint: must you look at both sides of the partition?)
[[4.21|Solution]]


:4.22. The ''median'' of a set of &lt;math&gt;n&lt;/math&gt; values is the &lt;math&gt;[n/2]&lt;/math&gt;th smallest value.
:(a) Suppose quicksort always pivoted on the median of the current sub-array. How many comparisons would quicksort make then in the worst case?
:(b) Suppose quicksort always pivoted on the &lt;math&gt;[n/3]&lt;/math&gt;th smallest value of the current sub-array. How many comparisons would be made then in the worst case?


:[[4.23]]. Suppose an array &lt;math&gt;A&lt;/math&gt; consists of &lt;math&gt;n&lt;/math&gt; elements, each of which is ''red'', ''white'', or ''blue'. We seek to sort the elements so that all the ''reds'' come before all the ''whites'', which come before all the ''blues''. The only operations permitted on the keys are:
::• ''Examine''(&lt;math&gt;A,i&lt;/math&gt;) – report the color of the &lt;math&gt;i&lt;/math&gt;th element of &lt;math&gt;A&lt;/math&gt;.
::• ''Swap''(&lt;math&gt;A,i,j&lt;/math&gt;) – swap the &lt;math&gt;i&lt;/math&gt;th element of &lt;math&gt;A&lt;/math&gt; with the &lt;math&gt;j&lt;/math&gt;th element.
:Find a correct and efficient algorithm for red–white–blue sorting. There is a linear-time solution.
[[4.23|Solution]]


:4.24. Give an efficient algorithm to rearrange an array of &lt;math&gt;n&lt;/math&gt; keys so that all the negative keys precede all the non-negative keys. Your algorithm must be in-place, meaning you cannot allocate another array to temporarily hold the items. How fast is your algorithm?


:[[4.25]]. Consider a given pair of different elements in an input array to be sorted, say &lt;math&gt;z_i&lt;/math&gt; and &lt;math&gt;z_j&lt;/math&gt; . What is the most number of times &lt;math&gt;z_i&lt;/math&gt; and &lt;math&gt;z_j&lt;/math&gt; might be compared with each other during an execution of quicksort?
[[4.25|Solution]]


:4.26. Define the recursion depth of quicksort as the maximum number of successive recursive calls it makes before hitting the base case. What are the minimum and maximum possible recursion depths for randomized quicksort?


:[[4.27]]. Suppose you are given a permutation &lt;math&gt;p&lt;/math&gt; of the integers 1 to &lt;math&gt;n&lt;/math&gt;, and seek to sort them to be in increasing order &lt;math&gt;[1, . . . , n]&lt;/math&gt;. The only operation at your disposal is ''reverse''&lt;math&gt;(p,i,j)&lt;/math&gt;, which reverses the elements of a subsequence &lt;math&gt;p_i, . . . , p_j&lt;/math&gt; in the permutation. For the permutation [1, 4, 3, 2, 5] one reversal (of the second through fourth elements) suffices to sort.
:• Show that it is possible to sort any permutation using &lt;math&gt;O(n)&lt;/math&gt; reversals.
:• Now suppose that the cost of ''reverse''&lt;math&gt;(p,i,j)&lt;/math&gt; is equal to its length, the number of elements in the range, &lt;math&gt;|j - i| + 1&lt;/math&gt;. Design an algorithm that sorts &lt;math&gt;p&lt;/math&gt; in &lt;math&gt;O(n log^2 n)&lt;/math&gt; cost. Analyze the running time and cost of your algorithm and prove correctness.
[[4.27|Solution]]

===Mergesort===

:4.28. Consider the following modification to merge sort: divide the input array into thirds (rather than halves), recursively sort each third, and finally combine the results using a three-way merge subroutine. What is the worst-case running time of this modified merge sort?


:[[4.29]]. Suppose you are given &lt;math&gt;k&lt;/math&gt; sorted arrays, each with &lt;math&gt;n&lt;/math&gt; elements, and you want to combine them into a single sorted array of &lt;math&gt;kn&lt;/math&gt; elements. One approach is to use the merge subroutine repeatedly, merging the first two arrays, then merging the result with the third array, then with the fourth array, and so on until you merge in the &lt;math&gt;k&lt;/math&gt;th and final input array. What is the running time?
[[4.29|Solution]]


:4.30. Consider again the problem of merging &lt;math&gt;k&lt;/math&gt; sorted length-&lt;math&gt;n&lt;/math&gt; arrays into a single sorted length-&lt;math&gt;kn&lt;/math&gt; array. Consider the algorithm that first divides the &lt;math&gt;k&lt;/math&gt; arrays into &lt;math&gt;k/2&lt;/math&gt; pairs of arrays, and uses the merge subroutine to combine each pair, resulting in &lt;math&gt;k/2&lt;/math&gt; sorted length-&lt;math&gt;2n&lt;/math&gt; arrays. The algorithm repeats this step until there is only one length-&lt;math&gt;know&lt;/math&gt; sorted array. What is the running time as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;?

===Other Sorting Alogrithims===

:[[4.31]]. Stable sorting algorithms leave equal-key items in the same relative order as in the original permutation. Explain what must be done to ensure that mergesort is a stable sorting algorithm.
[[4.31|Solution]]


:4.32. Wiggle sort: Given an unsorted array &lt;math&gt;A&lt;/math&gt;, reorder it such that &lt;math&gt;A[0] &lt; A[1] &gt; A[2] &lt; A[3] . . . .&lt;/math&gt; For example, one possible answer for input [3, 1, 4, 2, 6, 5] is [1, 3, 2, 5, 4, 6]. Can you do it in &lt;math&gt;O(n)&lt;/math&gt; time using only &lt;math&gt;O(1)&lt;/math&gt; space?


:[[4.33]]. Show that &lt;math&gt;n&lt;/math&gt; positive integers in the range 1 to &lt;math&gt;k&lt;/math&gt; can be sorted in &lt;math&gt;O(n log k)&lt;/math&gt; time. The interesting case is when &lt;math&gt;k \ll n&lt;/math&gt;.
[[4.33|Solution]]


:4.34. Consider a sequence &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers with many duplications, such that the number of distinct integers in &lt;math&gt;S&lt;/math&gt; is &lt;math&gt;O(log n)&lt;/math&gt;. Give an &lt;math&gt;O(n log log n)&lt;/math&gt; worst-case time algorithm to sort such sequences.


:[[4.35]]. Let &lt;math&gt;A[1..n]&lt;/math&gt; be an array such that the first &lt;math&gt;n -
\sqrt n&lt;/math&gt; elements are already sorted (though we know nothing about the remaining elements). Give an algorithm that sorts &lt;math&gt;A&lt;/math&gt; in substantially better than &lt;math&gt;n log n&lt;/math&gt; steps.
[[4.35|Solution]]


:4.36. Assume that the array &lt;math&gt;A[1..n]&lt;/math&gt; only has numbers from &lt;math&gt;{1, . . . , n^2}&lt;/math&gt; but that at most &lt;math&gt;log log n&lt;/math&gt; of these numbers ever appear. Devise an algorithm that sorts &lt;math&gt;A&lt;/math&gt; in substantially less than &lt;math&gt;O(n log n)&lt;/math&gt;.


:[[4.37]]. Consider the problem of sorting a sequence of &lt;math&gt;n&lt;/math&gt; 0’s and 1’s using comparisons. For each comparison of two values &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt;, the algorithm learns which of &lt;math&gt;x &lt; y, x = y&lt;/math&gt;, or &lt;math&gt;x &gt; y&lt;/math&gt; holds.
:(a) Give an algorithm to sort in &lt;math&gt;n - 1&lt;/math&gt; comparisons in the worst case. Show that your algorithm is optimal.
:(b) Give an algorithm to sort in &lt;math&gt;2n/3&lt;/math&gt; comparisons in the average case (assuming each of the &lt;math&gt;n&lt;/math&gt; inputs is 0 or 1 with equal probability). Show that your algorithm is optimal.
[[4.37|Solution]]


:4.38. Let &lt;math&gt;P&lt;/math&gt; be a simple, but not necessarily convex, &lt;math&gt;n&lt;/math&gt;-sided polygon and &lt;math&gt;q&lt;/math&gt; an arbitrary point not necessarily in &lt;math&gt;P&lt;/math&gt;. Design an efficient algorithm to find a line segment originating from &lt;math&gt;q&lt;/math&gt; that intersects the maximum number of edges of &lt;math&gt;P&lt;/math&gt;. 
:In other words, if standing at point &lt;math&gt;q&lt;/math&gt;, in what direction should you aim a gun so the bullet will go through the largest number of walls. A bullet through a vertex of &lt;math&gt;P&lt;/math&gt; gets credit for only one wall. An &lt;math&gt;O(n log n)&lt;/math&gt; algorithm is possible.

===Lower Bounds===

:[[4.39]]


:4.40


===Searching===

:[[4.41]]


:4.42


===Implementaion Challenges===

:[[4.43]]


:4.44


:[[4.45]]


:4.46

===Interview Problems===

:[[4.47]]


:4.48


:[[4.49]]


:4.50


:[[4.51]]


:4.52


:[[4.53]]


Back to [[Chapter List]]</text>
      <sha1>5l3wb9mmqgnevxlzi6ci2p6fkmo1o7y</sha1>
    </revision>
    <revision>
      <id>274</id>
      <parentid>273</parentid>
      <timestamp>2020-09-19T20:37:18Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Lower Bounds */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="17250">=Sorting=

===Applications of Sorting: Numbers===

:[[4.1]]. The Grinch is given the job of partitioning &lt;math&gt;2n&lt;/math&gt; players into two teams of &lt;math&gt;n&lt;/math&gt; players each. Each player has a numerical rating that measures how good he or she is at the game. The Grinch seeks to divide the players as ''unfairly'' as possible, so as to create the biggest possible talent imbalance between the teams. Show how the Grinch can do the job in &lt;math&gt;O(n log n)&lt;/math&gt; time.
[[4.1|Solution]]


:4.2. For each of the following problems, give an algorithm that finds the desired numbers within the given amount of time. To keep your answers brief, feel free to use algorithms from the book as subroutines. For the example, &lt;math&gt;S = {6, 13, 19, 3, 8}&lt;/math&gt;, 19 - 3 maximizes the difference, while 8 - 6 minimizes the difference.
:(a) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x-y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.
:(b) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x - y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(1)&lt;/math&gt; worst-case time.
:(c) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n log n)&lt;/math&gt; worst-case time.
:(d) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.


:[[4.3]]. Take a list of &lt;math&gt;2n&lt;/math&gt; real numbers as input. Design an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm that partitions the numbers into &lt;math&gt;n&lt;/math&gt; pairs, with the property that the partition minimizes the maximum sum of a pair. For example, say we are given the numbers (1,3,5,9). The possible partitions are ((1,3),(5,9)), ((1,5),(3,9)), and ((1,9),(3,5)). The pair sums for these partitions are (4,14), (6,12), and (10,8). Thus, the third partition has 10 as its maximum sum, which is the minimum over the three partitions.
[[4.3|Solution]]


:4.4. Assume that we are given &lt;math&gt;n&lt;/math&gt; pairs of items as input, where the first item is a number and the second item is one of three colors (red, blue, or yellow). Further assume that the items are sorted by number. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm to sort the items by color (all reds before all blues before all yellows) such that the numbers for identical colors stay sorted.
:For example: (1,blue), (3,red), (4,blue), (6,yellow), (9,red) should become (3,red), (9,red), (1,blue), (4,blue), (6,yellow).


:[[4.5]]. The ''mode'' of a bag of numbers is the number that occurs most frequently in the set. The set {4, 6, 2, 4, 3, 1} has a mode of 4. Give an efficient and correct algorithm to compute the mode of a bag of &lt;math&gt;n&lt;/math&gt; numbers.
[[4.5|Solution]]


:4.6. Given two sets &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt; (each of size &lt;math&gt;n&lt;/math&gt;), and a number &lt;math&gt;x&lt;/math&gt;, describe an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for finding whether there exists a pair of elements, one from &lt;math&gt;S_1&lt;/math&gt; and one from &lt;math&gt;S_2&lt;/math&gt;, that add up to &lt;math&gt;x&lt;/math&gt;. (For partial credit, give a &lt;math&gt;\Theta(n^2)&lt;/math&gt; algorithm for this problem.)


:[[4.7]]. Give an efficient algorithm to take the array of citation counts (each count is a non-negative integer) of a researcher’s papers, and compute the researcher’s &lt;math&gt;h&lt;/math&gt;-index. By definition, a scientist has index &lt;math&gt;h&lt;/math&gt; if &lt;math&gt;h&lt;/math&gt; of his or her &lt;math&gt;n&lt;/math&gt; papers have been cited at least &lt;math&gt;h&lt;/math&gt; times, while the other &lt;math&gt;n-h&lt;/math&gt; papers each have no more than &lt;math&gt;h&lt;/math&gt; citations.
[[4.7|Solution]]


:4.8. Outline a reasonable method of solving each of the following problems. Give the order of the worst-case complexity of your methods.
:(a) You are given a pile of thousands of telephone bills and thousands of checks sent in to pay the bills. Find out who did not pay.
:(b) You are given a printed list containing the title, author, call number, and publisher of all the books in a school library and another list of thirty publishers. Find out how many of the books in the library were published by each company.
:(c) You are given all the book checkout cards used in the campus library during the past year, each of which contains the name of the person who took out the book. Determine how many distinct people checked out at least one book.


:[[4.9]]. Given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers and an integer &lt;math&gt;T&lt;/math&gt;, give an &lt;math&gt;O(n^{k-1}log n)&lt;/math&gt; algorithm to test whether &lt;math&gt;k&lt;/math&gt; of the integers in &lt;math&gt;S&lt;/math&gt; add up to &lt;math&gt;T&lt;/math&gt;.
[[4.9|Solution]]


:4.10. We are given a set of &lt;math&gt;S&lt;/math&gt; containing &lt;math&gt;n&lt;/math&gt; real numbers and a real number &lt;math&gt;x&lt;/math&gt;, and seek efficient algorithms to determine whether two elements of &lt;math&gt;S&lt;/math&gt; exist whose sum is exactly &lt;math&gt;x&lt;/math&gt;.
:(a) Assume that &lt;math&gt;S&lt;/math&gt; is unsorted. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for the problem.
:(b) Assume that &lt;math&gt;S&lt;/math&gt; is sorted. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for the problem.


:[[4.11]]. Design an &lt;math&gt;O(n)&lt;/math&gt; algorithm that, given a list of &lt;math&gt;n&lt;/math&gt; elements, finds all the elements that appear more than &lt;math&gt;n/2&lt;/math&gt; times in the list. Then, design an &lt;math&gt;O(n)&lt;/math&gt; algorithm that, given a list of &lt;math&gt;n&lt;/math&gt; elements, finds all the elements that appear more than &lt;math&gt;n/4&lt;/math&gt; times.
[[4.11|Solution]]

===Applications of Sorting: Intervals and Sets===

:4.12. Give an efficient algorithm to compute the union of sets &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt;, where &lt;math&gt;n = max(|A|, |B|)&lt;/math&gt;. The output should be an array of distinct elements that form the union of the sets.
:(a) Assume that &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; are unsorted arrays. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for the problem.
:(b) Assume that &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; are sorted arrays. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for the problem.


:[[4.13]]. A camera at the door tracks the entry time &lt;math&gt;a_i&lt;/math&gt; and exit time &lt;math&gt;b_i&lt;/math&gt; (assume &lt;math&gt;b_i &gt; a_i&lt;/math&gt;) for each of &lt;math&gt;n&lt;/math&gt; persons &lt;math&gt;p_i&lt;/math&gt; attending a party. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm that analyzes this data to determine the time when the most people were simultaneously present at the party. You may assume that all entry and exit times are distinct (no ties).
[[4.13|Solution]]


:4.14. Given a list &lt;math&gt;I&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; intervals, specified as &lt;math&gt;(x_i, y_i)&lt;/math&gt; pairs, return a list where the overlapping intervals are merged. For &lt;math&gt;I = {(1, 3),(2, 6),(8, 10),(7, 18)}&lt;/math&gt; the output should be &lt;math&gt;{(1, 6),(7, 18)}&lt;/math&gt;. Your algorithm should run in worst-case &lt;math&gt;O(n log n)&lt;/math&gt; time complexity.


:[[4.15]]. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; intervals on a line, with the &lt;math&gt;i&lt;/math&gt;th interval described by its left and right endpoints &lt;math&gt;(l_i, r_i)&lt;/math&gt;. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm to identify a point &lt;math&gt;p&lt;/math&gt; on the line that is in the largest number of intervals.
:As an example, for &lt;math&gt;S = {(10, 40),(20, 60),(50, 90),(15, 70)}&lt;/math&gt; no point exists in all four intervals, but &lt;math&gt;p = 50&lt;/math&gt; is an example of a point in three intervals. You can assume an endpoint counts as being in its interval.
[[4.15|Solution]]


:4.16. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; segments on the line, where segment &lt;math&gt;S_i&lt;/math&gt; ranges from &lt;math&gt;l_i&lt;/math&gt; to &lt;math&gt;r_i&lt;/math&gt;. Give an efficient algorithm to select the fewest number of segments whose union completely covers the interval from 0 to &lt;math&gt;m&lt;/math&gt;.

===Heaps===

:[[4.17]]. Devise an algorithm for finding the &lt;math&gt;k&lt;/math&gt; smallest elements of an unsorted set of &lt;math&gt;n&lt;/math&gt; integers in &lt;math&gt;O(n + k log n)&lt;/math&gt;.
[[4.17|Solution]]


:4.18. Give an &lt;math&gt;O(n log k)&lt;/math&gt;-time algorithm that merges &lt;math&gt;k&lt;/math&gt; sorted lists with a total of &lt;math&gt;n&lt;/math&gt; elements into one sorted list. (Hint: use a heap to speed up the obvious &lt;math&gt;O(know)&lt;/math&gt;-time algorithm).


:[[4.19]]. You wish to store a set of &lt;math&gt;n&lt;/math&gt; numbers in either a max-heap or a sorted array. For each application below, state which data structure is better, or if it does not matter. Explain your answers.
:(a) Find the maximum element quickly.
:(b) Delete an element quickly.
:(c) Form the structure quickly.
:(d) Find the minimum element quickly.
[[4.19|Solution]]


:4.20. (a) Give an efficient algorithm to find the second-largest key among &lt;math&gt;n&lt;/math&gt; keys. You can do better than &lt;math&gt;2n - 3&lt;/math&gt; comparisons.
:(b) Then, give an efficient algorithm to find the third-largest key among &lt;math&gt;n&lt;/math&gt; keys. How many key comparisons does your algorithm do in the worst case? Must your algorithm determine which key is largest and second-largest in the process?

===Quicksort===

:[[4.21]]. Use the partitioning idea of quicksort to give an algorithm that finds the median element of an array of &lt;math&gt;n&lt;/math&gt; integers in expected &lt;math&gt;O(n)&lt;/math&gt; time. (Hint: must you look at both sides of the partition?)
[[4.21|Solution]]


:4.22. The ''median'' of a set of &lt;math&gt;n&lt;/math&gt; values is the &lt;math&gt;[n/2]&lt;/math&gt;th smallest value.
:(a) Suppose quicksort always pivoted on the median of the current sub-array. How many comparisons would quicksort make then in the worst case?
:(b) Suppose quicksort always pivoted on the &lt;math&gt;[n/3]&lt;/math&gt;th smallest value of the current sub-array. How many comparisons would be made then in the worst case?


:[[4.23]]. Suppose an array &lt;math&gt;A&lt;/math&gt; consists of &lt;math&gt;n&lt;/math&gt; elements, each of which is ''red'', ''white'', or ''blue'. We seek to sort the elements so that all the ''reds'' come before all the ''whites'', which come before all the ''blues''. The only operations permitted on the keys are:
::• ''Examine''(&lt;math&gt;A,i&lt;/math&gt;) – report the color of the &lt;math&gt;i&lt;/math&gt;th element of &lt;math&gt;A&lt;/math&gt;.
::• ''Swap''(&lt;math&gt;A,i,j&lt;/math&gt;) – swap the &lt;math&gt;i&lt;/math&gt;th element of &lt;math&gt;A&lt;/math&gt; with the &lt;math&gt;j&lt;/math&gt;th element.
:Find a correct and efficient algorithm for red–white–blue sorting. There is a linear-time solution.
[[4.23|Solution]]


:4.24. Give an efficient algorithm to rearrange an array of &lt;math&gt;n&lt;/math&gt; keys so that all the negative keys precede all the non-negative keys. Your algorithm must be in-place, meaning you cannot allocate another array to temporarily hold the items. How fast is your algorithm?


:[[4.25]]. Consider a given pair of different elements in an input array to be sorted, say &lt;math&gt;z_i&lt;/math&gt; and &lt;math&gt;z_j&lt;/math&gt; . What is the most number of times &lt;math&gt;z_i&lt;/math&gt; and &lt;math&gt;z_j&lt;/math&gt; might be compared with each other during an execution of quicksort?
[[4.25|Solution]]


:4.26. Define the recursion depth of quicksort as the maximum number of successive recursive calls it makes before hitting the base case. What are the minimum and maximum possible recursion depths for randomized quicksort?


:[[4.27]]. Suppose you are given a permutation &lt;math&gt;p&lt;/math&gt; of the integers 1 to &lt;math&gt;n&lt;/math&gt;, and seek to sort them to be in increasing order &lt;math&gt;[1, . . . , n]&lt;/math&gt;. The only operation at your disposal is ''reverse''&lt;math&gt;(p,i,j)&lt;/math&gt;, which reverses the elements of a subsequence &lt;math&gt;p_i, . . . , p_j&lt;/math&gt; in the permutation. For the permutation [1, 4, 3, 2, 5] one reversal (of the second through fourth elements) suffices to sort.
:• Show that it is possible to sort any permutation using &lt;math&gt;O(n)&lt;/math&gt; reversals.
:• Now suppose that the cost of ''reverse''&lt;math&gt;(p,i,j)&lt;/math&gt; is equal to its length, the number of elements in the range, &lt;math&gt;|j - i| + 1&lt;/math&gt;. Design an algorithm that sorts &lt;math&gt;p&lt;/math&gt; in &lt;math&gt;O(n log^2 n)&lt;/math&gt; cost. Analyze the running time and cost of your algorithm and prove correctness.
[[4.27|Solution]]

===Mergesort===

:4.28. Consider the following modification to merge sort: divide the input array into thirds (rather than halves), recursively sort each third, and finally combine the results using a three-way merge subroutine. What is the worst-case running time of this modified merge sort?


:[[4.29]]. Suppose you are given &lt;math&gt;k&lt;/math&gt; sorted arrays, each with &lt;math&gt;n&lt;/math&gt; elements, and you want to combine them into a single sorted array of &lt;math&gt;kn&lt;/math&gt; elements. One approach is to use the merge subroutine repeatedly, merging the first two arrays, then merging the result with the third array, then with the fourth array, and so on until you merge in the &lt;math&gt;k&lt;/math&gt;th and final input array. What is the running time?
[[4.29|Solution]]


:4.30. Consider again the problem of merging &lt;math&gt;k&lt;/math&gt; sorted length-&lt;math&gt;n&lt;/math&gt; arrays into a single sorted length-&lt;math&gt;kn&lt;/math&gt; array. Consider the algorithm that first divides the &lt;math&gt;k&lt;/math&gt; arrays into &lt;math&gt;k/2&lt;/math&gt; pairs of arrays, and uses the merge subroutine to combine each pair, resulting in &lt;math&gt;k/2&lt;/math&gt; sorted length-&lt;math&gt;2n&lt;/math&gt; arrays. The algorithm repeats this step until there is only one length-&lt;math&gt;know&lt;/math&gt; sorted array. What is the running time as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;?

===Other Sorting Alogrithims===

:[[4.31]]. Stable sorting algorithms leave equal-key items in the same relative order as in the original permutation. Explain what must be done to ensure that mergesort is a stable sorting algorithm.
[[4.31|Solution]]


:4.32. Wiggle sort: Given an unsorted array &lt;math&gt;A&lt;/math&gt;, reorder it such that &lt;math&gt;A[0] &lt; A[1] &gt; A[2] &lt; A[3] . . . .&lt;/math&gt; For example, one possible answer for input [3, 1, 4, 2, 6, 5] is [1, 3, 2, 5, 4, 6]. Can you do it in &lt;math&gt;O(n)&lt;/math&gt; time using only &lt;math&gt;O(1)&lt;/math&gt; space?


:[[4.33]]. Show that &lt;math&gt;n&lt;/math&gt; positive integers in the range 1 to &lt;math&gt;k&lt;/math&gt; can be sorted in &lt;math&gt;O(n log k)&lt;/math&gt; time. The interesting case is when &lt;math&gt;k \ll n&lt;/math&gt;.
[[4.33|Solution]]


:4.34. Consider a sequence &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers with many duplications, such that the number of distinct integers in &lt;math&gt;S&lt;/math&gt; is &lt;math&gt;O(log n)&lt;/math&gt;. Give an &lt;math&gt;O(n log log n)&lt;/math&gt; worst-case time algorithm to sort such sequences.


:[[4.35]]. Let &lt;math&gt;A[1..n]&lt;/math&gt; be an array such that the first &lt;math&gt;n -
\sqrt n&lt;/math&gt; elements are already sorted (though we know nothing about the remaining elements). Give an algorithm that sorts &lt;math&gt;A&lt;/math&gt; in substantially better than &lt;math&gt;n log n&lt;/math&gt; steps.
[[4.35|Solution]]


:4.36. Assume that the array &lt;math&gt;A[1..n]&lt;/math&gt; only has numbers from &lt;math&gt;{1, . . . , n^2}&lt;/math&gt; but that at most &lt;math&gt;log log n&lt;/math&gt; of these numbers ever appear. Devise an algorithm that sorts &lt;math&gt;A&lt;/math&gt; in substantially less than &lt;math&gt;O(n log n)&lt;/math&gt;.


:[[4.37]]. Consider the problem of sorting a sequence of &lt;math&gt;n&lt;/math&gt; 0’s and 1’s using comparisons. For each comparison of two values &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt;, the algorithm learns which of &lt;math&gt;x &lt; y, x = y&lt;/math&gt;, or &lt;math&gt;x &gt; y&lt;/math&gt; holds.
:(a) Give an algorithm to sort in &lt;math&gt;n - 1&lt;/math&gt; comparisons in the worst case. Show that your algorithm is optimal.
:(b) Give an algorithm to sort in &lt;math&gt;2n/3&lt;/math&gt; comparisons in the average case (assuming each of the &lt;math&gt;n&lt;/math&gt; inputs is 0 or 1 with equal probability). Show that your algorithm is optimal.
[[4.37|Solution]]


:4.38. Let &lt;math&gt;P&lt;/math&gt; be a simple, but not necessarily convex, &lt;math&gt;n&lt;/math&gt;-sided polygon and &lt;math&gt;q&lt;/math&gt; an arbitrary point not necessarily in &lt;math&gt;P&lt;/math&gt;. Design an efficient algorithm to find a line segment originating from &lt;math&gt;q&lt;/math&gt; that intersects the maximum number of edges of &lt;math&gt;P&lt;/math&gt;. 
:In other words, if standing at point &lt;math&gt;q&lt;/math&gt;, in what direction should you aim a gun so the bullet will go through the largest number of walls. A bullet through a vertex of &lt;math&gt;P&lt;/math&gt; gets credit for only one wall. An &lt;math&gt;O(n log n)&lt;/math&gt; algorithm is possible.

===Lower Bounds===

:[[4.39]]. In one of my research papers [Ski88], I discovered a comparison-based sorting algorithm that runs in &lt;math&gt;O(n log(\sqrt n))&lt;/math&gt;. Given the existence of an &lt;math&gt;\Omega(n log n)&lt;/math&gt; lower bound for sorting, how can this be possible?
[[4.39|Solution]]


:4.40. Mr. B. C. Dull claims to have developed a new data structure for priority queues that supports the operations ''Insert'', ''Maximum'', and ''Extract-Max''—all in &lt;math&gt;O(1)&lt;/math&gt; worst-case time. Prove that he is mistaken. (Hint: the argument does not involve a lot of gory details—just think about what this would imply about the &lt;math&gt;\Omega (n log n)&lt;/math&gt; lower bound for sorting.)

===Searching===

:[[4.41]]


:4.42


===Implementaion Challenges===

:[[4.43]]


:4.44


:[[4.45]]


:4.46

===Interview Problems===

:[[4.47]]


:4.48


:[[4.49]]


:4.50


:[[4.51]]


:4.52


:[[4.53]]


Back to [[Chapter List]]</text>
      <sha1>9xsrele3rae8jtjnlhs5ca08q9g2ioq</sha1>
    </revision>
    <revision>
      <id>275</id>
      <parentid>274</parentid>
      <timestamp>2020-09-19T20:42:06Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Searching */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="18552">=Sorting=

===Applications of Sorting: Numbers===

:[[4.1]]. The Grinch is given the job of partitioning &lt;math&gt;2n&lt;/math&gt; players into two teams of &lt;math&gt;n&lt;/math&gt; players each. Each player has a numerical rating that measures how good he or she is at the game. The Grinch seeks to divide the players as ''unfairly'' as possible, so as to create the biggest possible talent imbalance between the teams. Show how the Grinch can do the job in &lt;math&gt;O(n log n)&lt;/math&gt; time.
[[4.1|Solution]]


:4.2. For each of the following problems, give an algorithm that finds the desired numbers within the given amount of time. To keep your answers brief, feel free to use algorithms from the book as subroutines. For the example, &lt;math&gt;S = {6, 13, 19, 3, 8}&lt;/math&gt;, 19 - 3 maximizes the difference, while 8 - 6 minimizes the difference.
:(a) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x-y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.
:(b) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x - y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(1)&lt;/math&gt; worst-case time.
:(c) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n log n)&lt;/math&gt; worst-case time.
:(d) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.


:[[4.3]]. Take a list of &lt;math&gt;2n&lt;/math&gt; real numbers as input. Design an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm that partitions the numbers into &lt;math&gt;n&lt;/math&gt; pairs, with the property that the partition minimizes the maximum sum of a pair. For example, say we are given the numbers (1,3,5,9). The possible partitions are ((1,3),(5,9)), ((1,5),(3,9)), and ((1,9),(3,5)). The pair sums for these partitions are (4,14), (6,12), and (10,8). Thus, the third partition has 10 as its maximum sum, which is the minimum over the three partitions.
[[4.3|Solution]]


:4.4. Assume that we are given &lt;math&gt;n&lt;/math&gt; pairs of items as input, where the first item is a number and the second item is one of three colors (red, blue, or yellow). Further assume that the items are sorted by number. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm to sort the items by color (all reds before all blues before all yellows) such that the numbers for identical colors stay sorted.
:For example: (1,blue), (3,red), (4,blue), (6,yellow), (9,red) should become (3,red), (9,red), (1,blue), (4,blue), (6,yellow).


:[[4.5]]. The ''mode'' of a bag of numbers is the number that occurs most frequently in the set. The set {4, 6, 2, 4, 3, 1} has a mode of 4. Give an efficient and correct algorithm to compute the mode of a bag of &lt;math&gt;n&lt;/math&gt; numbers.
[[4.5|Solution]]


:4.6. Given two sets &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt; (each of size &lt;math&gt;n&lt;/math&gt;), and a number &lt;math&gt;x&lt;/math&gt;, describe an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for finding whether there exists a pair of elements, one from &lt;math&gt;S_1&lt;/math&gt; and one from &lt;math&gt;S_2&lt;/math&gt;, that add up to &lt;math&gt;x&lt;/math&gt;. (For partial credit, give a &lt;math&gt;\Theta(n^2)&lt;/math&gt; algorithm for this problem.)


:[[4.7]]. Give an efficient algorithm to take the array of citation counts (each count is a non-negative integer) of a researcher’s papers, and compute the researcher’s &lt;math&gt;h&lt;/math&gt;-index. By definition, a scientist has index &lt;math&gt;h&lt;/math&gt; if &lt;math&gt;h&lt;/math&gt; of his or her &lt;math&gt;n&lt;/math&gt; papers have been cited at least &lt;math&gt;h&lt;/math&gt; times, while the other &lt;math&gt;n-h&lt;/math&gt; papers each have no more than &lt;math&gt;h&lt;/math&gt; citations.
[[4.7|Solution]]


:4.8. Outline a reasonable method of solving each of the following problems. Give the order of the worst-case complexity of your methods.
:(a) You are given a pile of thousands of telephone bills and thousands of checks sent in to pay the bills. Find out who did not pay.
:(b) You are given a printed list containing the title, author, call number, and publisher of all the books in a school library and another list of thirty publishers. Find out how many of the books in the library were published by each company.
:(c) You are given all the book checkout cards used in the campus library during the past year, each of which contains the name of the person who took out the book. Determine how many distinct people checked out at least one book.


:[[4.9]]. Given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers and an integer &lt;math&gt;T&lt;/math&gt;, give an &lt;math&gt;O(n^{k-1}log n)&lt;/math&gt; algorithm to test whether &lt;math&gt;k&lt;/math&gt; of the integers in &lt;math&gt;S&lt;/math&gt; add up to &lt;math&gt;T&lt;/math&gt;.
[[4.9|Solution]]


:4.10. We are given a set of &lt;math&gt;S&lt;/math&gt; containing &lt;math&gt;n&lt;/math&gt; real numbers and a real number &lt;math&gt;x&lt;/math&gt;, and seek efficient algorithms to determine whether two elements of &lt;math&gt;S&lt;/math&gt; exist whose sum is exactly &lt;math&gt;x&lt;/math&gt;.
:(a) Assume that &lt;math&gt;S&lt;/math&gt; is unsorted. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for the problem.
:(b) Assume that &lt;math&gt;S&lt;/math&gt; is sorted. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for the problem.


:[[4.11]]. Design an &lt;math&gt;O(n)&lt;/math&gt; algorithm that, given a list of &lt;math&gt;n&lt;/math&gt; elements, finds all the elements that appear more than &lt;math&gt;n/2&lt;/math&gt; times in the list. Then, design an &lt;math&gt;O(n)&lt;/math&gt; algorithm that, given a list of &lt;math&gt;n&lt;/math&gt; elements, finds all the elements that appear more than &lt;math&gt;n/4&lt;/math&gt; times.
[[4.11|Solution]]

===Applications of Sorting: Intervals and Sets===

:4.12. Give an efficient algorithm to compute the union of sets &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt;, where &lt;math&gt;n = max(|A|, |B|)&lt;/math&gt;. The output should be an array of distinct elements that form the union of the sets.
:(a) Assume that &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; are unsorted arrays. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for the problem.
:(b) Assume that &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; are sorted arrays. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for the problem.


:[[4.13]]. A camera at the door tracks the entry time &lt;math&gt;a_i&lt;/math&gt; and exit time &lt;math&gt;b_i&lt;/math&gt; (assume &lt;math&gt;b_i &gt; a_i&lt;/math&gt;) for each of &lt;math&gt;n&lt;/math&gt; persons &lt;math&gt;p_i&lt;/math&gt; attending a party. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm that analyzes this data to determine the time when the most people were simultaneously present at the party. You may assume that all entry and exit times are distinct (no ties).
[[4.13|Solution]]


:4.14. Given a list &lt;math&gt;I&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; intervals, specified as &lt;math&gt;(x_i, y_i)&lt;/math&gt; pairs, return a list where the overlapping intervals are merged. For &lt;math&gt;I = {(1, 3),(2, 6),(8, 10),(7, 18)}&lt;/math&gt; the output should be &lt;math&gt;{(1, 6),(7, 18)}&lt;/math&gt;. Your algorithm should run in worst-case &lt;math&gt;O(n log n)&lt;/math&gt; time complexity.


:[[4.15]]. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; intervals on a line, with the &lt;math&gt;i&lt;/math&gt;th interval described by its left and right endpoints &lt;math&gt;(l_i, r_i)&lt;/math&gt;. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm to identify a point &lt;math&gt;p&lt;/math&gt; on the line that is in the largest number of intervals.
:As an example, for &lt;math&gt;S = {(10, 40),(20, 60),(50, 90),(15, 70)}&lt;/math&gt; no point exists in all four intervals, but &lt;math&gt;p = 50&lt;/math&gt; is an example of a point in three intervals. You can assume an endpoint counts as being in its interval.
[[4.15|Solution]]


:4.16. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; segments on the line, where segment &lt;math&gt;S_i&lt;/math&gt; ranges from &lt;math&gt;l_i&lt;/math&gt; to &lt;math&gt;r_i&lt;/math&gt;. Give an efficient algorithm to select the fewest number of segments whose union completely covers the interval from 0 to &lt;math&gt;m&lt;/math&gt;.

===Heaps===

:[[4.17]]. Devise an algorithm for finding the &lt;math&gt;k&lt;/math&gt; smallest elements of an unsorted set of &lt;math&gt;n&lt;/math&gt; integers in &lt;math&gt;O(n + k log n)&lt;/math&gt;.
[[4.17|Solution]]


:4.18. Give an &lt;math&gt;O(n log k)&lt;/math&gt;-time algorithm that merges &lt;math&gt;k&lt;/math&gt; sorted lists with a total of &lt;math&gt;n&lt;/math&gt; elements into one sorted list. (Hint: use a heap to speed up the obvious &lt;math&gt;O(know)&lt;/math&gt;-time algorithm).


:[[4.19]]. You wish to store a set of &lt;math&gt;n&lt;/math&gt; numbers in either a max-heap or a sorted array. For each application below, state which data structure is better, or if it does not matter. Explain your answers.
:(a) Find the maximum element quickly.
:(b) Delete an element quickly.
:(c) Form the structure quickly.
:(d) Find the minimum element quickly.
[[4.19|Solution]]


:4.20. (a) Give an efficient algorithm to find the second-largest key among &lt;math&gt;n&lt;/math&gt; keys. You can do better than &lt;math&gt;2n - 3&lt;/math&gt; comparisons.
:(b) Then, give an efficient algorithm to find the third-largest key among &lt;math&gt;n&lt;/math&gt; keys. How many key comparisons does your algorithm do in the worst case? Must your algorithm determine which key is largest and second-largest in the process?

===Quicksort===

:[[4.21]]. Use the partitioning idea of quicksort to give an algorithm that finds the median element of an array of &lt;math&gt;n&lt;/math&gt; integers in expected &lt;math&gt;O(n)&lt;/math&gt; time. (Hint: must you look at both sides of the partition?)
[[4.21|Solution]]


:4.22. The ''median'' of a set of &lt;math&gt;n&lt;/math&gt; values is the &lt;math&gt;[n/2]&lt;/math&gt;th smallest value.
:(a) Suppose quicksort always pivoted on the median of the current sub-array. How many comparisons would quicksort make then in the worst case?
:(b) Suppose quicksort always pivoted on the &lt;math&gt;[n/3]&lt;/math&gt;th smallest value of the current sub-array. How many comparisons would be made then in the worst case?


:[[4.23]]. Suppose an array &lt;math&gt;A&lt;/math&gt; consists of &lt;math&gt;n&lt;/math&gt; elements, each of which is ''red'', ''white'', or ''blue'. We seek to sort the elements so that all the ''reds'' come before all the ''whites'', which come before all the ''blues''. The only operations permitted on the keys are:
::• ''Examine''(&lt;math&gt;A,i&lt;/math&gt;) – report the color of the &lt;math&gt;i&lt;/math&gt;th element of &lt;math&gt;A&lt;/math&gt;.
::• ''Swap''(&lt;math&gt;A,i,j&lt;/math&gt;) – swap the &lt;math&gt;i&lt;/math&gt;th element of &lt;math&gt;A&lt;/math&gt; with the &lt;math&gt;j&lt;/math&gt;th element.
:Find a correct and efficient algorithm for red–white–blue sorting. There is a linear-time solution.
[[4.23|Solution]]


:4.24. Give an efficient algorithm to rearrange an array of &lt;math&gt;n&lt;/math&gt; keys so that all the negative keys precede all the non-negative keys. Your algorithm must be in-place, meaning you cannot allocate another array to temporarily hold the items. How fast is your algorithm?


:[[4.25]]. Consider a given pair of different elements in an input array to be sorted, say &lt;math&gt;z_i&lt;/math&gt; and &lt;math&gt;z_j&lt;/math&gt; . What is the most number of times &lt;math&gt;z_i&lt;/math&gt; and &lt;math&gt;z_j&lt;/math&gt; might be compared with each other during an execution of quicksort?
[[4.25|Solution]]


:4.26. Define the recursion depth of quicksort as the maximum number of successive recursive calls it makes before hitting the base case. What are the minimum and maximum possible recursion depths for randomized quicksort?


:[[4.27]]. Suppose you are given a permutation &lt;math&gt;p&lt;/math&gt; of the integers 1 to &lt;math&gt;n&lt;/math&gt;, and seek to sort them to be in increasing order &lt;math&gt;[1, . . . , n]&lt;/math&gt;. The only operation at your disposal is ''reverse''&lt;math&gt;(p,i,j)&lt;/math&gt;, which reverses the elements of a subsequence &lt;math&gt;p_i, . . . , p_j&lt;/math&gt; in the permutation. For the permutation [1, 4, 3, 2, 5] one reversal (of the second through fourth elements) suffices to sort.
:• Show that it is possible to sort any permutation using &lt;math&gt;O(n)&lt;/math&gt; reversals.
:• Now suppose that the cost of ''reverse''&lt;math&gt;(p,i,j)&lt;/math&gt; is equal to its length, the number of elements in the range, &lt;math&gt;|j - i| + 1&lt;/math&gt;. Design an algorithm that sorts &lt;math&gt;p&lt;/math&gt; in &lt;math&gt;O(n log^2 n)&lt;/math&gt; cost. Analyze the running time and cost of your algorithm and prove correctness.
[[4.27|Solution]]

===Mergesort===

:4.28. Consider the following modification to merge sort: divide the input array into thirds (rather than halves), recursively sort each third, and finally combine the results using a three-way merge subroutine. What is the worst-case running time of this modified merge sort?


:[[4.29]]. Suppose you are given &lt;math&gt;k&lt;/math&gt; sorted arrays, each with &lt;math&gt;n&lt;/math&gt; elements, and you want to combine them into a single sorted array of &lt;math&gt;kn&lt;/math&gt; elements. One approach is to use the merge subroutine repeatedly, merging the first two arrays, then merging the result with the third array, then with the fourth array, and so on until you merge in the &lt;math&gt;k&lt;/math&gt;th and final input array. What is the running time?
[[4.29|Solution]]


:4.30. Consider again the problem of merging &lt;math&gt;k&lt;/math&gt; sorted length-&lt;math&gt;n&lt;/math&gt; arrays into a single sorted length-&lt;math&gt;kn&lt;/math&gt; array. Consider the algorithm that first divides the &lt;math&gt;k&lt;/math&gt; arrays into &lt;math&gt;k/2&lt;/math&gt; pairs of arrays, and uses the merge subroutine to combine each pair, resulting in &lt;math&gt;k/2&lt;/math&gt; sorted length-&lt;math&gt;2n&lt;/math&gt; arrays. The algorithm repeats this step until there is only one length-&lt;math&gt;know&lt;/math&gt; sorted array. What is the running time as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;?

===Other Sorting Alogrithims===

:[[4.31]]. Stable sorting algorithms leave equal-key items in the same relative order as in the original permutation. Explain what must be done to ensure that mergesort is a stable sorting algorithm.
[[4.31|Solution]]


:4.32. Wiggle sort: Given an unsorted array &lt;math&gt;A&lt;/math&gt;, reorder it such that &lt;math&gt;A[0] &lt; A[1] &gt; A[2] &lt; A[3] . . . .&lt;/math&gt; For example, one possible answer for input [3, 1, 4, 2, 6, 5] is [1, 3, 2, 5, 4, 6]. Can you do it in &lt;math&gt;O(n)&lt;/math&gt; time using only &lt;math&gt;O(1)&lt;/math&gt; space?


:[[4.33]]. Show that &lt;math&gt;n&lt;/math&gt; positive integers in the range 1 to &lt;math&gt;k&lt;/math&gt; can be sorted in &lt;math&gt;O(n log k)&lt;/math&gt; time. The interesting case is when &lt;math&gt;k \ll n&lt;/math&gt;.
[[4.33|Solution]]


:4.34. Consider a sequence &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers with many duplications, such that the number of distinct integers in &lt;math&gt;S&lt;/math&gt; is &lt;math&gt;O(log n)&lt;/math&gt;. Give an &lt;math&gt;O(n log log n)&lt;/math&gt; worst-case time algorithm to sort such sequences.


:[[4.35]]. Let &lt;math&gt;A[1..n]&lt;/math&gt; be an array such that the first &lt;math&gt;n -
\sqrt n&lt;/math&gt; elements are already sorted (though we know nothing about the remaining elements). Give an algorithm that sorts &lt;math&gt;A&lt;/math&gt; in substantially better than &lt;math&gt;n log n&lt;/math&gt; steps.
[[4.35|Solution]]


:4.36. Assume that the array &lt;math&gt;A[1..n]&lt;/math&gt; only has numbers from &lt;math&gt;{1, . . . , n^2}&lt;/math&gt; but that at most &lt;math&gt;log log n&lt;/math&gt; of these numbers ever appear. Devise an algorithm that sorts &lt;math&gt;A&lt;/math&gt; in substantially less than &lt;math&gt;O(n log n)&lt;/math&gt;.


:[[4.37]]. Consider the problem of sorting a sequence of &lt;math&gt;n&lt;/math&gt; 0’s and 1’s using comparisons. For each comparison of two values &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt;, the algorithm learns which of &lt;math&gt;x &lt; y, x = y&lt;/math&gt;, or &lt;math&gt;x &gt; y&lt;/math&gt; holds.
:(a) Give an algorithm to sort in &lt;math&gt;n - 1&lt;/math&gt; comparisons in the worst case. Show that your algorithm is optimal.
:(b) Give an algorithm to sort in &lt;math&gt;2n/3&lt;/math&gt; comparisons in the average case (assuming each of the &lt;math&gt;n&lt;/math&gt; inputs is 0 or 1 with equal probability). Show that your algorithm is optimal.
[[4.37|Solution]]


:4.38. Let &lt;math&gt;P&lt;/math&gt; be a simple, but not necessarily convex, &lt;math&gt;n&lt;/math&gt;-sided polygon and &lt;math&gt;q&lt;/math&gt; an arbitrary point not necessarily in &lt;math&gt;P&lt;/math&gt;. Design an efficient algorithm to find a line segment originating from &lt;math&gt;q&lt;/math&gt; that intersects the maximum number of edges of &lt;math&gt;P&lt;/math&gt;. 
:In other words, if standing at point &lt;math&gt;q&lt;/math&gt;, in what direction should you aim a gun so the bullet will go through the largest number of walls. A bullet through a vertex of &lt;math&gt;P&lt;/math&gt; gets credit for only one wall. An &lt;math&gt;O(n log n)&lt;/math&gt; algorithm is possible.

===Lower Bounds===

:[[4.39]]. In one of my research papers [Ski88], I discovered a comparison-based sorting algorithm that runs in &lt;math&gt;O(n log(\sqrt n))&lt;/math&gt;. Given the existence of an &lt;math&gt;\Omega(n log n)&lt;/math&gt; lower bound for sorting, how can this be possible?
[[4.39|Solution]]


:4.40. Mr. B. C. Dull claims to have developed a new data structure for priority queues that supports the operations ''Insert'', ''Maximum'', and ''Extract-Max''—all in &lt;math&gt;O(1)&lt;/math&gt; worst-case time. Prove that he is mistaken. (Hint: the argument does not involve a lot of gory details—just think about what this would imply about the &lt;math&gt;\Omega (n log n)&lt;/math&gt; lower bound for sorting.)

===Searching===

:[[4.41]]. A company database consists of 10,000 sorted names, 40% of whom are known as good customers and who together account for 60% of the accesses to the database. There are two data structure options to consider for representing the database:
:• Put all the names in a single array and use binary search.
:• Put the good customers in one array and the rest of them in a second array. Only if we do not find the query name on a binary search of the first array do we do a binary search of the second array.
:Demonstrate which option gives better expected performance. Does this change if linear search on an unsorted array is used instead of binary search for both options?
[[4.41|Solution]]


:4.42. A ''Ramanujan number'' can be written two different ways as the sum of two cubes—meaning there exist distinct positive integers &lt;math&gt;a, b, c&lt;/math&gt;, and &lt;math&gt;d&lt;/math&gt; such that &lt;math&gt;a^3 + b^3 = c^3 + d^3&lt;/math&gt;. For example, 1729 is a Ramanujan number because &lt;math&gt;1729 = 1^3 + 12^3 = 9^3 + 10^3&lt;/math&gt;.
:(a) Give an efficient algorithm to test whether a given single integer &lt;math&gt;n&lt;/math&gt; is a Ramanujan number, with an analysis of the algorithm’s complexity.
:(b) Now give an efficient algorithm to generate all the Ramanujan numbers between 1 and &lt;math&gt;n&lt;/math&gt;, with an analysis of its complexity.

===Implementaion Challenges===

:[[4.43]]


:4.44


:[[4.45]]


:4.46

===Interview Problems===

:[[4.47]]


:4.48


:[[4.49]]


:4.50


:[[4.51]]


:4.52


:[[4.53]]


Back to [[Chapter List]]</text>
      <sha1>suwanhfvvdp8kusxkzawao1ipc5152c</sha1>
    </revision>
    <revision>
      <id>276</id>
      <parentid>275</parentid>
      <timestamp>2020-09-19T20:44:41Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Implementaion Challenges */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="20231">=Sorting=

===Applications of Sorting: Numbers===

:[[4.1]]. The Grinch is given the job of partitioning &lt;math&gt;2n&lt;/math&gt; players into two teams of &lt;math&gt;n&lt;/math&gt; players each. Each player has a numerical rating that measures how good he or she is at the game. The Grinch seeks to divide the players as ''unfairly'' as possible, so as to create the biggest possible talent imbalance between the teams. Show how the Grinch can do the job in &lt;math&gt;O(n log n)&lt;/math&gt; time.
[[4.1|Solution]]


:4.2. For each of the following problems, give an algorithm that finds the desired numbers within the given amount of time. To keep your answers brief, feel free to use algorithms from the book as subroutines. For the example, &lt;math&gt;S = {6, 13, 19, 3, 8}&lt;/math&gt;, 19 - 3 maximizes the difference, while 8 - 6 minimizes the difference.
:(a) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x-y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.
:(b) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x - y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(1)&lt;/math&gt; worst-case time.
:(c) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n log n)&lt;/math&gt; worst-case time.
:(d) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.


:[[4.3]]. Take a list of &lt;math&gt;2n&lt;/math&gt; real numbers as input. Design an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm that partitions the numbers into &lt;math&gt;n&lt;/math&gt; pairs, with the property that the partition minimizes the maximum sum of a pair. For example, say we are given the numbers (1,3,5,9). The possible partitions are ((1,3),(5,9)), ((1,5),(3,9)), and ((1,9),(3,5)). The pair sums for these partitions are (4,14), (6,12), and (10,8). Thus, the third partition has 10 as its maximum sum, which is the minimum over the three partitions.
[[4.3|Solution]]


:4.4. Assume that we are given &lt;math&gt;n&lt;/math&gt; pairs of items as input, where the first item is a number and the second item is one of three colors (red, blue, or yellow). Further assume that the items are sorted by number. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm to sort the items by color (all reds before all blues before all yellows) such that the numbers for identical colors stay sorted.
:For example: (1,blue), (3,red), (4,blue), (6,yellow), (9,red) should become (3,red), (9,red), (1,blue), (4,blue), (6,yellow).


:[[4.5]]. The ''mode'' of a bag of numbers is the number that occurs most frequently in the set. The set {4, 6, 2, 4, 3, 1} has a mode of 4. Give an efficient and correct algorithm to compute the mode of a bag of &lt;math&gt;n&lt;/math&gt; numbers.
[[4.5|Solution]]


:4.6. Given two sets &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt; (each of size &lt;math&gt;n&lt;/math&gt;), and a number &lt;math&gt;x&lt;/math&gt;, describe an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for finding whether there exists a pair of elements, one from &lt;math&gt;S_1&lt;/math&gt; and one from &lt;math&gt;S_2&lt;/math&gt;, that add up to &lt;math&gt;x&lt;/math&gt;. (For partial credit, give a &lt;math&gt;\Theta(n^2)&lt;/math&gt; algorithm for this problem.)


:[[4.7]]. Give an efficient algorithm to take the array of citation counts (each count is a non-negative integer) of a researcher’s papers, and compute the researcher’s &lt;math&gt;h&lt;/math&gt;-index. By definition, a scientist has index &lt;math&gt;h&lt;/math&gt; if &lt;math&gt;h&lt;/math&gt; of his or her &lt;math&gt;n&lt;/math&gt; papers have been cited at least &lt;math&gt;h&lt;/math&gt; times, while the other &lt;math&gt;n-h&lt;/math&gt; papers each have no more than &lt;math&gt;h&lt;/math&gt; citations.
[[4.7|Solution]]


:4.8. Outline a reasonable method of solving each of the following problems. Give the order of the worst-case complexity of your methods.
:(a) You are given a pile of thousands of telephone bills and thousands of checks sent in to pay the bills. Find out who did not pay.
:(b) You are given a printed list containing the title, author, call number, and publisher of all the books in a school library and another list of thirty publishers. Find out how many of the books in the library were published by each company.
:(c) You are given all the book checkout cards used in the campus library during the past year, each of which contains the name of the person who took out the book. Determine how many distinct people checked out at least one book.


:[[4.9]]. Given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers and an integer &lt;math&gt;T&lt;/math&gt;, give an &lt;math&gt;O(n^{k-1}log n)&lt;/math&gt; algorithm to test whether &lt;math&gt;k&lt;/math&gt; of the integers in &lt;math&gt;S&lt;/math&gt; add up to &lt;math&gt;T&lt;/math&gt;.
[[4.9|Solution]]


:4.10. We are given a set of &lt;math&gt;S&lt;/math&gt; containing &lt;math&gt;n&lt;/math&gt; real numbers and a real number &lt;math&gt;x&lt;/math&gt;, and seek efficient algorithms to determine whether two elements of &lt;math&gt;S&lt;/math&gt; exist whose sum is exactly &lt;math&gt;x&lt;/math&gt;.
:(a) Assume that &lt;math&gt;S&lt;/math&gt; is unsorted. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for the problem.
:(b) Assume that &lt;math&gt;S&lt;/math&gt; is sorted. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for the problem.


:[[4.11]]. Design an &lt;math&gt;O(n)&lt;/math&gt; algorithm that, given a list of &lt;math&gt;n&lt;/math&gt; elements, finds all the elements that appear more than &lt;math&gt;n/2&lt;/math&gt; times in the list. Then, design an &lt;math&gt;O(n)&lt;/math&gt; algorithm that, given a list of &lt;math&gt;n&lt;/math&gt; elements, finds all the elements that appear more than &lt;math&gt;n/4&lt;/math&gt; times.
[[4.11|Solution]]

===Applications of Sorting: Intervals and Sets===

:4.12. Give an efficient algorithm to compute the union of sets &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt;, where &lt;math&gt;n = max(|A|, |B|)&lt;/math&gt;. The output should be an array of distinct elements that form the union of the sets.
:(a) Assume that &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; are unsorted arrays. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for the problem.
:(b) Assume that &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; are sorted arrays. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for the problem.


:[[4.13]]. A camera at the door tracks the entry time &lt;math&gt;a_i&lt;/math&gt; and exit time &lt;math&gt;b_i&lt;/math&gt; (assume &lt;math&gt;b_i &gt; a_i&lt;/math&gt;) for each of &lt;math&gt;n&lt;/math&gt; persons &lt;math&gt;p_i&lt;/math&gt; attending a party. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm that analyzes this data to determine the time when the most people were simultaneously present at the party. You may assume that all entry and exit times are distinct (no ties).
[[4.13|Solution]]


:4.14. Given a list &lt;math&gt;I&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; intervals, specified as &lt;math&gt;(x_i, y_i)&lt;/math&gt; pairs, return a list where the overlapping intervals are merged. For &lt;math&gt;I = {(1, 3),(2, 6),(8, 10),(7, 18)}&lt;/math&gt; the output should be &lt;math&gt;{(1, 6),(7, 18)}&lt;/math&gt;. Your algorithm should run in worst-case &lt;math&gt;O(n log n)&lt;/math&gt; time complexity.


:[[4.15]]. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; intervals on a line, with the &lt;math&gt;i&lt;/math&gt;th interval described by its left and right endpoints &lt;math&gt;(l_i, r_i)&lt;/math&gt;. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm to identify a point &lt;math&gt;p&lt;/math&gt; on the line that is in the largest number of intervals.
:As an example, for &lt;math&gt;S = {(10, 40),(20, 60),(50, 90),(15, 70)}&lt;/math&gt; no point exists in all four intervals, but &lt;math&gt;p = 50&lt;/math&gt; is an example of a point in three intervals. You can assume an endpoint counts as being in its interval.
[[4.15|Solution]]


:4.16. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; segments on the line, where segment &lt;math&gt;S_i&lt;/math&gt; ranges from &lt;math&gt;l_i&lt;/math&gt; to &lt;math&gt;r_i&lt;/math&gt;. Give an efficient algorithm to select the fewest number of segments whose union completely covers the interval from 0 to &lt;math&gt;m&lt;/math&gt;.

===Heaps===

:[[4.17]]. Devise an algorithm for finding the &lt;math&gt;k&lt;/math&gt; smallest elements of an unsorted set of &lt;math&gt;n&lt;/math&gt; integers in &lt;math&gt;O(n + k log n)&lt;/math&gt;.
[[4.17|Solution]]


:4.18. Give an &lt;math&gt;O(n log k)&lt;/math&gt;-time algorithm that merges &lt;math&gt;k&lt;/math&gt; sorted lists with a total of &lt;math&gt;n&lt;/math&gt; elements into one sorted list. (Hint: use a heap to speed up the obvious &lt;math&gt;O(know)&lt;/math&gt;-time algorithm).


:[[4.19]]. You wish to store a set of &lt;math&gt;n&lt;/math&gt; numbers in either a max-heap or a sorted array. For each application below, state which data structure is better, or if it does not matter. Explain your answers.
:(a) Find the maximum element quickly.
:(b) Delete an element quickly.
:(c) Form the structure quickly.
:(d) Find the minimum element quickly.
[[4.19|Solution]]


:4.20. (a) Give an efficient algorithm to find the second-largest key among &lt;math&gt;n&lt;/math&gt; keys. You can do better than &lt;math&gt;2n - 3&lt;/math&gt; comparisons.
:(b) Then, give an efficient algorithm to find the third-largest key among &lt;math&gt;n&lt;/math&gt; keys. How many key comparisons does your algorithm do in the worst case? Must your algorithm determine which key is largest and second-largest in the process?

===Quicksort===

:[[4.21]]. Use the partitioning idea of quicksort to give an algorithm that finds the median element of an array of &lt;math&gt;n&lt;/math&gt; integers in expected &lt;math&gt;O(n)&lt;/math&gt; time. (Hint: must you look at both sides of the partition?)
[[4.21|Solution]]


:4.22. The ''median'' of a set of &lt;math&gt;n&lt;/math&gt; values is the &lt;math&gt;[n/2]&lt;/math&gt;th smallest value.
:(a) Suppose quicksort always pivoted on the median of the current sub-array. How many comparisons would quicksort make then in the worst case?
:(b) Suppose quicksort always pivoted on the &lt;math&gt;[n/3]&lt;/math&gt;th smallest value of the current sub-array. How many comparisons would be made then in the worst case?


:[[4.23]]. Suppose an array &lt;math&gt;A&lt;/math&gt; consists of &lt;math&gt;n&lt;/math&gt; elements, each of which is ''red'', ''white'', or ''blue'. We seek to sort the elements so that all the ''reds'' come before all the ''whites'', which come before all the ''blues''. The only operations permitted on the keys are:
::• ''Examine''(&lt;math&gt;A,i&lt;/math&gt;) – report the color of the &lt;math&gt;i&lt;/math&gt;th element of &lt;math&gt;A&lt;/math&gt;.
::• ''Swap''(&lt;math&gt;A,i,j&lt;/math&gt;) – swap the &lt;math&gt;i&lt;/math&gt;th element of &lt;math&gt;A&lt;/math&gt; with the &lt;math&gt;j&lt;/math&gt;th element.
:Find a correct and efficient algorithm for red–white–blue sorting. There is a linear-time solution.
[[4.23|Solution]]


:4.24. Give an efficient algorithm to rearrange an array of &lt;math&gt;n&lt;/math&gt; keys so that all the negative keys precede all the non-negative keys. Your algorithm must be in-place, meaning you cannot allocate another array to temporarily hold the items. How fast is your algorithm?


:[[4.25]]. Consider a given pair of different elements in an input array to be sorted, say &lt;math&gt;z_i&lt;/math&gt; and &lt;math&gt;z_j&lt;/math&gt; . What is the most number of times &lt;math&gt;z_i&lt;/math&gt; and &lt;math&gt;z_j&lt;/math&gt; might be compared with each other during an execution of quicksort?
[[4.25|Solution]]


:4.26. Define the recursion depth of quicksort as the maximum number of successive recursive calls it makes before hitting the base case. What are the minimum and maximum possible recursion depths for randomized quicksort?


:[[4.27]]. Suppose you are given a permutation &lt;math&gt;p&lt;/math&gt; of the integers 1 to &lt;math&gt;n&lt;/math&gt;, and seek to sort them to be in increasing order &lt;math&gt;[1, . . . , n]&lt;/math&gt;. The only operation at your disposal is ''reverse''&lt;math&gt;(p,i,j)&lt;/math&gt;, which reverses the elements of a subsequence &lt;math&gt;p_i, . . . , p_j&lt;/math&gt; in the permutation. For the permutation [1, 4, 3, 2, 5] one reversal (of the second through fourth elements) suffices to sort.
:• Show that it is possible to sort any permutation using &lt;math&gt;O(n)&lt;/math&gt; reversals.
:• Now suppose that the cost of ''reverse''&lt;math&gt;(p,i,j)&lt;/math&gt; is equal to its length, the number of elements in the range, &lt;math&gt;|j - i| + 1&lt;/math&gt;. Design an algorithm that sorts &lt;math&gt;p&lt;/math&gt; in &lt;math&gt;O(n log^2 n)&lt;/math&gt; cost. Analyze the running time and cost of your algorithm and prove correctness.
[[4.27|Solution]]

===Mergesort===

:4.28. Consider the following modification to merge sort: divide the input array into thirds (rather than halves), recursively sort each third, and finally combine the results using a three-way merge subroutine. What is the worst-case running time of this modified merge sort?


:[[4.29]]. Suppose you are given &lt;math&gt;k&lt;/math&gt; sorted arrays, each with &lt;math&gt;n&lt;/math&gt; elements, and you want to combine them into a single sorted array of &lt;math&gt;kn&lt;/math&gt; elements. One approach is to use the merge subroutine repeatedly, merging the first two arrays, then merging the result with the third array, then with the fourth array, and so on until you merge in the &lt;math&gt;k&lt;/math&gt;th and final input array. What is the running time?
[[4.29|Solution]]


:4.30. Consider again the problem of merging &lt;math&gt;k&lt;/math&gt; sorted length-&lt;math&gt;n&lt;/math&gt; arrays into a single sorted length-&lt;math&gt;kn&lt;/math&gt; array. Consider the algorithm that first divides the &lt;math&gt;k&lt;/math&gt; arrays into &lt;math&gt;k/2&lt;/math&gt; pairs of arrays, and uses the merge subroutine to combine each pair, resulting in &lt;math&gt;k/2&lt;/math&gt; sorted length-&lt;math&gt;2n&lt;/math&gt; arrays. The algorithm repeats this step until there is only one length-&lt;math&gt;know&lt;/math&gt; sorted array. What is the running time as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;?

===Other Sorting Alogrithims===

:[[4.31]]. Stable sorting algorithms leave equal-key items in the same relative order as in the original permutation. Explain what must be done to ensure that mergesort is a stable sorting algorithm.
[[4.31|Solution]]


:4.32. Wiggle sort: Given an unsorted array &lt;math&gt;A&lt;/math&gt;, reorder it such that &lt;math&gt;A[0] &lt; A[1] &gt; A[2] &lt; A[3] . . . .&lt;/math&gt; For example, one possible answer for input [3, 1, 4, 2, 6, 5] is [1, 3, 2, 5, 4, 6]. Can you do it in &lt;math&gt;O(n)&lt;/math&gt; time using only &lt;math&gt;O(1)&lt;/math&gt; space?


:[[4.33]]. Show that &lt;math&gt;n&lt;/math&gt; positive integers in the range 1 to &lt;math&gt;k&lt;/math&gt; can be sorted in &lt;math&gt;O(n log k)&lt;/math&gt; time. The interesting case is when &lt;math&gt;k \ll n&lt;/math&gt;.
[[4.33|Solution]]


:4.34. Consider a sequence &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers with many duplications, such that the number of distinct integers in &lt;math&gt;S&lt;/math&gt; is &lt;math&gt;O(log n)&lt;/math&gt;. Give an &lt;math&gt;O(n log log n)&lt;/math&gt; worst-case time algorithm to sort such sequences.


:[[4.35]]. Let &lt;math&gt;A[1..n]&lt;/math&gt; be an array such that the first &lt;math&gt;n -
\sqrt n&lt;/math&gt; elements are already sorted (though we know nothing about the remaining elements). Give an algorithm that sorts &lt;math&gt;A&lt;/math&gt; in substantially better than &lt;math&gt;n log n&lt;/math&gt; steps.
[[4.35|Solution]]


:4.36. Assume that the array &lt;math&gt;A[1..n]&lt;/math&gt; only has numbers from &lt;math&gt;{1, . . . , n^2}&lt;/math&gt; but that at most &lt;math&gt;log log n&lt;/math&gt; of these numbers ever appear. Devise an algorithm that sorts &lt;math&gt;A&lt;/math&gt; in substantially less than &lt;math&gt;O(n log n)&lt;/math&gt;.


:[[4.37]]. Consider the problem of sorting a sequence of &lt;math&gt;n&lt;/math&gt; 0’s and 1’s using comparisons. For each comparison of two values &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt;, the algorithm learns which of &lt;math&gt;x &lt; y, x = y&lt;/math&gt;, or &lt;math&gt;x &gt; y&lt;/math&gt; holds.
:(a) Give an algorithm to sort in &lt;math&gt;n - 1&lt;/math&gt; comparisons in the worst case. Show that your algorithm is optimal.
:(b) Give an algorithm to sort in &lt;math&gt;2n/3&lt;/math&gt; comparisons in the average case (assuming each of the &lt;math&gt;n&lt;/math&gt; inputs is 0 or 1 with equal probability). Show that your algorithm is optimal.
[[4.37|Solution]]


:4.38. Let &lt;math&gt;P&lt;/math&gt; be a simple, but not necessarily convex, &lt;math&gt;n&lt;/math&gt;-sided polygon and &lt;math&gt;q&lt;/math&gt; an arbitrary point not necessarily in &lt;math&gt;P&lt;/math&gt;. Design an efficient algorithm to find a line segment originating from &lt;math&gt;q&lt;/math&gt; that intersects the maximum number of edges of &lt;math&gt;P&lt;/math&gt;. 
:In other words, if standing at point &lt;math&gt;q&lt;/math&gt;, in what direction should you aim a gun so the bullet will go through the largest number of walls. A bullet through a vertex of &lt;math&gt;P&lt;/math&gt; gets credit for only one wall. An &lt;math&gt;O(n log n)&lt;/math&gt; algorithm is possible.

===Lower Bounds===

:[[4.39]]. In one of my research papers [Ski88], I discovered a comparison-based sorting algorithm that runs in &lt;math&gt;O(n log(\sqrt n))&lt;/math&gt;. Given the existence of an &lt;math&gt;\Omega(n log n)&lt;/math&gt; lower bound for sorting, how can this be possible?
[[4.39|Solution]]


:4.40. Mr. B. C. Dull claims to have developed a new data structure for priority queues that supports the operations ''Insert'', ''Maximum'', and ''Extract-Max''—all in &lt;math&gt;O(1)&lt;/math&gt; worst-case time. Prove that he is mistaken. (Hint: the argument does not involve a lot of gory details—just think about what this would imply about the &lt;math&gt;\Omega (n log n)&lt;/math&gt; lower bound for sorting.)

===Searching===

:[[4.41]]. A company database consists of 10,000 sorted names, 40% of whom are known as good customers and who together account for 60% of the accesses to the database. There are two data structure options to consider for representing the database:
:• Put all the names in a single array and use binary search.
:• Put the good customers in one array and the rest of them in a second array. Only if we do not find the query name on a binary search of the first array do we do a binary search of the second array.
:Demonstrate which option gives better expected performance. Does this change if linear search on an unsorted array is used instead of binary search for both options?
[[4.41|Solution]]


:4.42. A ''Ramanujan number'' can be written two different ways as the sum of two cubes—meaning there exist distinct positive integers &lt;math&gt;a, b, c&lt;/math&gt;, and &lt;math&gt;d&lt;/math&gt; such that &lt;math&gt;a^3 + b^3 = c^3 + d^3&lt;/math&gt;. For example, 1729 is a Ramanujan number because &lt;math&gt;1729 = 1^3 + 12^3 = 9^3 + 10^3&lt;/math&gt;.
:(a) Give an efficient algorithm to test whether a given single integer &lt;math&gt;n&lt;/math&gt; is a Ramanujan number, with an analysis of the algorithm’s complexity.
:(b) Now give an efficient algorithm to generate all the Ramanujan numbers between 1 and &lt;math&gt;n&lt;/math&gt;, with an analysis of its complexity.

===Implementaion Challenges===

:[[4.43]]. Consider an n×n array &lt;math&gt;A&lt;/math&gt; containing integer elements (positive, negative, and zero). Assume that the elements in each row of &lt;math&gt;A&lt;/math&gt; are in strictly increasing order, and the elements of each column of &lt;math&gt;A&lt;/math&gt; are in strictly decreasing order. (Hence there cannot be two zeros in the same row or the same column.) Describe an efficient algorithm that counts the number of occurrences of the element 0 in &lt;math&gt;A&lt;/math&gt;. Analyze its running time.
[[4.43|Solution]]


:4.44. Implement versions of several different sorting algorithms, such as selection sort, insertion sort, heapsort, mergesort, and quicksort. Conduct experiments to assess the relative performance of these algorithms in a simple application that reads a large text file and reports exactly one instance of each word that appears within it. This application can be efficiently implemented by sorting all the words that occur in the text and then passing through the sorted sequence to identify one instance of each distinct word. Write a brief report with your conclusions.


:[[4.45]]. Implement an external sort, which uses intermediate files to sort files bigger than main memory. Mergesort is a good algorithm to base such an implementation on. Test your program both on files with small records and on files with large records.
[[4.45|Solution]]


:4.46. Design and implement a parallel sorting algorithm that distributes data across several processors. An appropriate variation of mergesort is a likely candidate. Measure the speedup of this algorithm as the number of processors increases. Then compare the execution time to that of a purely sequential mergesort implementation. What are your experiences?

===Interview Problems===

:[[4.47]]


:4.48


:[[4.49]]


:4.50


:[[4.51]]


:4.52


:[[4.53]]


Back to [[Chapter List]]</text>
      <sha1>e6jfzi72gqw65a90b7gyyetlsvfkcd2</sha1>
    </revision>
    <revision>
      <id>277</id>
      <parentid>276</parentid>
      <timestamp>2020-09-19T20:48:10Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Interview Problems */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="21397">=Sorting=

===Applications of Sorting: Numbers===

:[[4.1]]. The Grinch is given the job of partitioning &lt;math&gt;2n&lt;/math&gt; players into two teams of &lt;math&gt;n&lt;/math&gt; players each. Each player has a numerical rating that measures how good he or she is at the game. The Grinch seeks to divide the players as ''unfairly'' as possible, so as to create the biggest possible talent imbalance between the teams. Show how the Grinch can do the job in &lt;math&gt;O(n log n)&lt;/math&gt; time.
[[4.1|Solution]]


:4.2. For each of the following problems, give an algorithm that finds the desired numbers within the given amount of time. To keep your answers brief, feel free to use algorithms from the book as subroutines. For the example, &lt;math&gt;S = {6, 13, 19, 3, 8}&lt;/math&gt;, 19 - 3 maximizes the difference, while 8 - 6 minimizes the difference.
:(a) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x-y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.
:(b) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x - y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(1)&lt;/math&gt; worst-case time.
:(c) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n log n)&lt;/math&gt; worst-case time.
:(d) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.


:[[4.3]]. Take a list of &lt;math&gt;2n&lt;/math&gt; real numbers as input. Design an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm that partitions the numbers into &lt;math&gt;n&lt;/math&gt; pairs, with the property that the partition minimizes the maximum sum of a pair. For example, say we are given the numbers (1,3,5,9). The possible partitions are ((1,3),(5,9)), ((1,5),(3,9)), and ((1,9),(3,5)). The pair sums for these partitions are (4,14), (6,12), and (10,8). Thus, the third partition has 10 as its maximum sum, which is the minimum over the three partitions.
[[4.3|Solution]]


:4.4. Assume that we are given &lt;math&gt;n&lt;/math&gt; pairs of items as input, where the first item is a number and the second item is one of three colors (red, blue, or yellow). Further assume that the items are sorted by number. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm to sort the items by color (all reds before all blues before all yellows) such that the numbers for identical colors stay sorted.
:For example: (1,blue), (3,red), (4,blue), (6,yellow), (9,red) should become (3,red), (9,red), (1,blue), (4,blue), (6,yellow).


:[[4.5]]. The ''mode'' of a bag of numbers is the number that occurs most frequently in the set. The set {4, 6, 2, 4, 3, 1} has a mode of 4. Give an efficient and correct algorithm to compute the mode of a bag of &lt;math&gt;n&lt;/math&gt; numbers.
[[4.5|Solution]]


:4.6. Given two sets &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt; (each of size &lt;math&gt;n&lt;/math&gt;), and a number &lt;math&gt;x&lt;/math&gt;, describe an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for finding whether there exists a pair of elements, one from &lt;math&gt;S_1&lt;/math&gt; and one from &lt;math&gt;S_2&lt;/math&gt;, that add up to &lt;math&gt;x&lt;/math&gt;. (For partial credit, give a &lt;math&gt;\Theta(n^2)&lt;/math&gt; algorithm for this problem.)


:[[4.7]]. Give an efficient algorithm to take the array of citation counts (each count is a non-negative integer) of a researcher’s papers, and compute the researcher’s &lt;math&gt;h&lt;/math&gt;-index. By definition, a scientist has index &lt;math&gt;h&lt;/math&gt; if &lt;math&gt;h&lt;/math&gt; of his or her &lt;math&gt;n&lt;/math&gt; papers have been cited at least &lt;math&gt;h&lt;/math&gt; times, while the other &lt;math&gt;n-h&lt;/math&gt; papers each have no more than &lt;math&gt;h&lt;/math&gt; citations.
[[4.7|Solution]]


:4.8. Outline a reasonable method of solving each of the following problems. Give the order of the worst-case complexity of your methods.
:(a) You are given a pile of thousands of telephone bills and thousands of checks sent in to pay the bills. Find out who did not pay.
:(b) You are given a printed list containing the title, author, call number, and publisher of all the books in a school library and another list of thirty publishers. Find out how many of the books in the library were published by each company.
:(c) You are given all the book checkout cards used in the campus library during the past year, each of which contains the name of the person who took out the book. Determine how many distinct people checked out at least one book.


:[[4.9]]. Given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers and an integer &lt;math&gt;T&lt;/math&gt;, give an &lt;math&gt;O(n^{k-1}log n)&lt;/math&gt; algorithm to test whether &lt;math&gt;k&lt;/math&gt; of the integers in &lt;math&gt;S&lt;/math&gt; add up to &lt;math&gt;T&lt;/math&gt;.
[[4.9|Solution]]


:4.10. We are given a set of &lt;math&gt;S&lt;/math&gt; containing &lt;math&gt;n&lt;/math&gt; real numbers and a real number &lt;math&gt;x&lt;/math&gt;, and seek efficient algorithms to determine whether two elements of &lt;math&gt;S&lt;/math&gt; exist whose sum is exactly &lt;math&gt;x&lt;/math&gt;.
:(a) Assume that &lt;math&gt;S&lt;/math&gt; is unsorted. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for the problem.
:(b) Assume that &lt;math&gt;S&lt;/math&gt; is sorted. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for the problem.


:[[4.11]]. Design an &lt;math&gt;O(n)&lt;/math&gt; algorithm that, given a list of &lt;math&gt;n&lt;/math&gt; elements, finds all the elements that appear more than &lt;math&gt;n/2&lt;/math&gt; times in the list. Then, design an &lt;math&gt;O(n)&lt;/math&gt; algorithm that, given a list of &lt;math&gt;n&lt;/math&gt; elements, finds all the elements that appear more than &lt;math&gt;n/4&lt;/math&gt; times.
[[4.11|Solution]]

===Applications of Sorting: Intervals and Sets===

:4.12. Give an efficient algorithm to compute the union of sets &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt;, where &lt;math&gt;n = max(|A|, |B|)&lt;/math&gt;. The output should be an array of distinct elements that form the union of the sets.
:(a) Assume that &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; are unsorted arrays. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for the problem.
:(b) Assume that &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; are sorted arrays. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for the problem.


:[[4.13]]. A camera at the door tracks the entry time &lt;math&gt;a_i&lt;/math&gt; and exit time &lt;math&gt;b_i&lt;/math&gt; (assume &lt;math&gt;b_i &gt; a_i&lt;/math&gt;) for each of &lt;math&gt;n&lt;/math&gt; persons &lt;math&gt;p_i&lt;/math&gt; attending a party. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm that analyzes this data to determine the time when the most people were simultaneously present at the party. You may assume that all entry and exit times are distinct (no ties).
[[4.13|Solution]]


:4.14. Given a list &lt;math&gt;I&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; intervals, specified as &lt;math&gt;(x_i, y_i)&lt;/math&gt; pairs, return a list where the overlapping intervals are merged. For &lt;math&gt;I = {(1, 3),(2, 6),(8, 10),(7, 18)}&lt;/math&gt; the output should be &lt;math&gt;{(1, 6),(7, 18)}&lt;/math&gt;. Your algorithm should run in worst-case &lt;math&gt;O(n log n)&lt;/math&gt; time complexity.


:[[4.15]]. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; intervals on a line, with the &lt;math&gt;i&lt;/math&gt;th interval described by its left and right endpoints &lt;math&gt;(l_i, r_i)&lt;/math&gt;. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm to identify a point &lt;math&gt;p&lt;/math&gt; on the line that is in the largest number of intervals.
:As an example, for &lt;math&gt;S = {(10, 40),(20, 60),(50, 90),(15, 70)}&lt;/math&gt; no point exists in all four intervals, but &lt;math&gt;p = 50&lt;/math&gt; is an example of a point in three intervals. You can assume an endpoint counts as being in its interval.
[[4.15|Solution]]


:4.16. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; segments on the line, where segment &lt;math&gt;S_i&lt;/math&gt; ranges from &lt;math&gt;l_i&lt;/math&gt; to &lt;math&gt;r_i&lt;/math&gt;. Give an efficient algorithm to select the fewest number of segments whose union completely covers the interval from 0 to &lt;math&gt;m&lt;/math&gt;.

===Heaps===

:[[4.17]]. Devise an algorithm for finding the &lt;math&gt;k&lt;/math&gt; smallest elements of an unsorted set of &lt;math&gt;n&lt;/math&gt; integers in &lt;math&gt;O(n + k log n)&lt;/math&gt;.
[[4.17|Solution]]


:4.18. Give an &lt;math&gt;O(n log k)&lt;/math&gt;-time algorithm that merges &lt;math&gt;k&lt;/math&gt; sorted lists with a total of &lt;math&gt;n&lt;/math&gt; elements into one sorted list. (Hint: use a heap to speed up the obvious &lt;math&gt;O(know)&lt;/math&gt;-time algorithm).


:[[4.19]]. You wish to store a set of &lt;math&gt;n&lt;/math&gt; numbers in either a max-heap or a sorted array. For each application below, state which data structure is better, or if it does not matter. Explain your answers.
:(a) Find the maximum element quickly.
:(b) Delete an element quickly.
:(c) Form the structure quickly.
:(d) Find the minimum element quickly.
[[4.19|Solution]]


:4.20. (a) Give an efficient algorithm to find the second-largest key among &lt;math&gt;n&lt;/math&gt; keys. You can do better than &lt;math&gt;2n - 3&lt;/math&gt; comparisons.
:(b) Then, give an efficient algorithm to find the third-largest key among &lt;math&gt;n&lt;/math&gt; keys. How many key comparisons does your algorithm do in the worst case? Must your algorithm determine which key is largest and second-largest in the process?

===Quicksort===

:[[4.21]]. Use the partitioning idea of quicksort to give an algorithm that finds the median element of an array of &lt;math&gt;n&lt;/math&gt; integers in expected &lt;math&gt;O(n)&lt;/math&gt; time. (Hint: must you look at both sides of the partition?)
[[4.21|Solution]]


:4.22. The ''median'' of a set of &lt;math&gt;n&lt;/math&gt; values is the &lt;math&gt;[n/2]&lt;/math&gt;th smallest value.
:(a) Suppose quicksort always pivoted on the median of the current sub-array. How many comparisons would quicksort make then in the worst case?
:(b) Suppose quicksort always pivoted on the &lt;math&gt;[n/3]&lt;/math&gt;th smallest value of the current sub-array. How many comparisons would be made then in the worst case?


:[[4.23]]. Suppose an array &lt;math&gt;A&lt;/math&gt; consists of &lt;math&gt;n&lt;/math&gt; elements, each of which is ''red'', ''white'', or ''blue'. We seek to sort the elements so that all the ''reds'' come before all the ''whites'', which come before all the ''blues''. The only operations permitted on the keys are:
::• ''Examine''(&lt;math&gt;A,i&lt;/math&gt;) – report the color of the &lt;math&gt;i&lt;/math&gt;th element of &lt;math&gt;A&lt;/math&gt;.
::• ''Swap''(&lt;math&gt;A,i,j&lt;/math&gt;) – swap the &lt;math&gt;i&lt;/math&gt;th element of &lt;math&gt;A&lt;/math&gt; with the &lt;math&gt;j&lt;/math&gt;th element.
:Find a correct and efficient algorithm for red–white–blue sorting. There is a linear-time solution.
[[4.23|Solution]]


:4.24. Give an efficient algorithm to rearrange an array of &lt;math&gt;n&lt;/math&gt; keys so that all the negative keys precede all the non-negative keys. Your algorithm must be in-place, meaning you cannot allocate another array to temporarily hold the items. How fast is your algorithm?


:[[4.25]]. Consider a given pair of different elements in an input array to be sorted, say &lt;math&gt;z_i&lt;/math&gt; and &lt;math&gt;z_j&lt;/math&gt; . What is the most number of times &lt;math&gt;z_i&lt;/math&gt; and &lt;math&gt;z_j&lt;/math&gt; might be compared with each other during an execution of quicksort?
[[4.25|Solution]]


:4.26. Define the recursion depth of quicksort as the maximum number of successive recursive calls it makes before hitting the base case. What are the minimum and maximum possible recursion depths for randomized quicksort?


:[[4.27]]. Suppose you are given a permutation &lt;math&gt;p&lt;/math&gt; of the integers 1 to &lt;math&gt;n&lt;/math&gt;, and seek to sort them to be in increasing order &lt;math&gt;[1, . . . , n]&lt;/math&gt;. The only operation at your disposal is ''reverse''&lt;math&gt;(p,i,j)&lt;/math&gt;, which reverses the elements of a subsequence &lt;math&gt;p_i, . . . , p_j&lt;/math&gt; in the permutation. For the permutation [1, 4, 3, 2, 5] one reversal (of the second through fourth elements) suffices to sort.
:• Show that it is possible to sort any permutation using &lt;math&gt;O(n)&lt;/math&gt; reversals.
:• Now suppose that the cost of ''reverse''&lt;math&gt;(p,i,j)&lt;/math&gt; is equal to its length, the number of elements in the range, &lt;math&gt;|j - i| + 1&lt;/math&gt;. Design an algorithm that sorts &lt;math&gt;p&lt;/math&gt; in &lt;math&gt;O(n log^2 n)&lt;/math&gt; cost. Analyze the running time and cost of your algorithm and prove correctness.
[[4.27|Solution]]

===Mergesort===

:4.28. Consider the following modification to merge sort: divide the input array into thirds (rather than halves), recursively sort each third, and finally combine the results using a three-way merge subroutine. What is the worst-case running time of this modified merge sort?


:[[4.29]]. Suppose you are given &lt;math&gt;k&lt;/math&gt; sorted arrays, each with &lt;math&gt;n&lt;/math&gt; elements, and you want to combine them into a single sorted array of &lt;math&gt;kn&lt;/math&gt; elements. One approach is to use the merge subroutine repeatedly, merging the first two arrays, then merging the result with the third array, then with the fourth array, and so on until you merge in the &lt;math&gt;k&lt;/math&gt;th and final input array. What is the running time?
[[4.29|Solution]]


:4.30. Consider again the problem of merging &lt;math&gt;k&lt;/math&gt; sorted length-&lt;math&gt;n&lt;/math&gt; arrays into a single sorted length-&lt;math&gt;kn&lt;/math&gt; array. Consider the algorithm that first divides the &lt;math&gt;k&lt;/math&gt; arrays into &lt;math&gt;k/2&lt;/math&gt; pairs of arrays, and uses the merge subroutine to combine each pair, resulting in &lt;math&gt;k/2&lt;/math&gt; sorted length-&lt;math&gt;2n&lt;/math&gt; arrays. The algorithm repeats this step until there is only one length-&lt;math&gt;know&lt;/math&gt; sorted array. What is the running time as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;?

===Other Sorting Alogrithims===

:[[4.31]]. Stable sorting algorithms leave equal-key items in the same relative order as in the original permutation. Explain what must be done to ensure that mergesort is a stable sorting algorithm.
[[4.31|Solution]]


:4.32. Wiggle sort: Given an unsorted array &lt;math&gt;A&lt;/math&gt;, reorder it such that &lt;math&gt;A[0] &lt; A[1] &gt; A[2] &lt; A[3] . . . .&lt;/math&gt; For example, one possible answer for input [3, 1, 4, 2, 6, 5] is [1, 3, 2, 5, 4, 6]. Can you do it in &lt;math&gt;O(n)&lt;/math&gt; time using only &lt;math&gt;O(1)&lt;/math&gt; space?


:[[4.33]]. Show that &lt;math&gt;n&lt;/math&gt; positive integers in the range 1 to &lt;math&gt;k&lt;/math&gt; can be sorted in &lt;math&gt;O(n log k)&lt;/math&gt; time. The interesting case is when &lt;math&gt;k \ll n&lt;/math&gt;.
[[4.33|Solution]]


:4.34. Consider a sequence &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers with many duplications, such that the number of distinct integers in &lt;math&gt;S&lt;/math&gt; is &lt;math&gt;O(log n)&lt;/math&gt;. Give an &lt;math&gt;O(n log log n)&lt;/math&gt; worst-case time algorithm to sort such sequences.


:[[4.35]]. Let &lt;math&gt;A[1..n]&lt;/math&gt; be an array such that the first &lt;math&gt;n -
\sqrt n&lt;/math&gt; elements are already sorted (though we know nothing about the remaining elements). Give an algorithm that sorts &lt;math&gt;A&lt;/math&gt; in substantially better than &lt;math&gt;n log n&lt;/math&gt; steps.
[[4.35|Solution]]


:4.36. Assume that the array &lt;math&gt;A[1..n]&lt;/math&gt; only has numbers from &lt;math&gt;{1, . . . , n^2}&lt;/math&gt; but that at most &lt;math&gt;log log n&lt;/math&gt; of these numbers ever appear. Devise an algorithm that sorts &lt;math&gt;A&lt;/math&gt; in substantially less than &lt;math&gt;O(n log n)&lt;/math&gt;.


:[[4.37]]. Consider the problem of sorting a sequence of &lt;math&gt;n&lt;/math&gt; 0’s and 1’s using comparisons. For each comparison of two values &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt;, the algorithm learns which of &lt;math&gt;x &lt; y, x = y&lt;/math&gt;, or &lt;math&gt;x &gt; y&lt;/math&gt; holds.
:(a) Give an algorithm to sort in &lt;math&gt;n - 1&lt;/math&gt; comparisons in the worst case. Show that your algorithm is optimal.
:(b) Give an algorithm to sort in &lt;math&gt;2n/3&lt;/math&gt; comparisons in the average case (assuming each of the &lt;math&gt;n&lt;/math&gt; inputs is 0 or 1 with equal probability). Show that your algorithm is optimal.
[[4.37|Solution]]


:4.38. Let &lt;math&gt;P&lt;/math&gt; be a simple, but not necessarily convex, &lt;math&gt;n&lt;/math&gt;-sided polygon and &lt;math&gt;q&lt;/math&gt; an arbitrary point not necessarily in &lt;math&gt;P&lt;/math&gt;. Design an efficient algorithm to find a line segment originating from &lt;math&gt;q&lt;/math&gt; that intersects the maximum number of edges of &lt;math&gt;P&lt;/math&gt;. 
:In other words, if standing at point &lt;math&gt;q&lt;/math&gt;, in what direction should you aim a gun so the bullet will go through the largest number of walls. A bullet through a vertex of &lt;math&gt;P&lt;/math&gt; gets credit for only one wall. An &lt;math&gt;O(n log n)&lt;/math&gt; algorithm is possible.

===Lower Bounds===

:[[4.39]]. In one of my research papers [Ski88], I discovered a comparison-based sorting algorithm that runs in &lt;math&gt;O(n log(\sqrt n))&lt;/math&gt;. Given the existence of an &lt;math&gt;\Omega(n log n)&lt;/math&gt; lower bound for sorting, how can this be possible?
[[4.39|Solution]]


:4.40. Mr. B. C. Dull claims to have developed a new data structure for priority queues that supports the operations ''Insert'', ''Maximum'', and ''Extract-Max''—all in &lt;math&gt;O(1)&lt;/math&gt; worst-case time. Prove that he is mistaken. (Hint: the argument does not involve a lot of gory details—just think about what this would imply about the &lt;math&gt;\Omega (n log n)&lt;/math&gt; lower bound for sorting.)

===Searching===

:[[4.41]]. A company database consists of 10,000 sorted names, 40% of whom are known as good customers and who together account for 60% of the accesses to the database. There are two data structure options to consider for representing the database:
:• Put all the names in a single array and use binary search.
:• Put the good customers in one array and the rest of them in a second array. Only if we do not find the query name on a binary search of the first array do we do a binary search of the second array.
:Demonstrate which option gives better expected performance. Does this change if linear search on an unsorted array is used instead of binary search for both options?
[[4.41|Solution]]


:4.42. A ''Ramanujan number'' can be written two different ways as the sum of two cubes—meaning there exist distinct positive integers &lt;math&gt;a, b, c&lt;/math&gt;, and &lt;math&gt;d&lt;/math&gt; such that &lt;math&gt;a^3 + b^3 = c^3 + d^3&lt;/math&gt;. For example, 1729 is a Ramanujan number because &lt;math&gt;1729 = 1^3 + 12^3 = 9^3 + 10^3&lt;/math&gt;.
:(a) Give an efficient algorithm to test whether a given single integer &lt;math&gt;n&lt;/math&gt; is a Ramanujan number, with an analysis of the algorithm’s complexity.
:(b) Now give an efficient algorithm to generate all the Ramanujan numbers between 1 and &lt;math&gt;n&lt;/math&gt;, with an analysis of its complexity.

===Implementaion Challenges===

:[[4.43]]. Consider an n×n array &lt;math&gt;A&lt;/math&gt; containing integer elements (positive, negative, and zero). Assume that the elements in each row of &lt;math&gt;A&lt;/math&gt; are in strictly increasing order, and the elements of each column of &lt;math&gt;A&lt;/math&gt; are in strictly decreasing order. (Hence there cannot be two zeros in the same row or the same column.) Describe an efficient algorithm that counts the number of occurrences of the element 0 in &lt;math&gt;A&lt;/math&gt;. Analyze its running time.
[[4.43|Solution]]


:4.44. Implement versions of several different sorting algorithms, such as selection sort, insertion sort, heapsort, mergesort, and quicksort. Conduct experiments to assess the relative performance of these algorithms in a simple application that reads a large text file and reports exactly one instance of each word that appears within it. This application can be efficiently implemented by sorting all the words that occur in the text and then passing through the sorted sequence to identify one instance of each distinct word. Write a brief report with your conclusions.


:[[4.45]]. Implement an external sort, which uses intermediate files to sort files bigger than main memory. Mergesort is a good algorithm to base such an implementation on. Test your program both on files with small records and on files with large records.
[[4.45|Solution]]


:4.46. Design and implement a parallel sorting algorithm that distributes data across several processors. An appropriate variation of mergesort is a likely candidate. Measure the speedup of this algorithm as the number of processors increases. Then compare the execution time to that of a purely sequential mergesort implementation. What are your experiences?

===Interview Problems===

:[[4.47]]. If you are given a million integers to sort, what algorithm would you use to sort them? How much time and memory would that consume?
[[4.47|Solution]]


:4.48. Describe advantages and disadvantages of the most popular sorting algorithms.


:[[4.49]]. Implement an algorithm that takes an input array and returns only the unique elements in it.
[[4.49|Solution]]


:4.50. You have a computer with only 4 GB of main memory. How do you use it to sort a large file of 500 GB that is on disk?


:[[4.51]]. Design a stack that supports push, pop, and retrieving the minimum element in constant time.
[[4.51|Solution]]


:4.52. Given a search string of three words, find the smallest snippet of the document that contains all three of the search words—that is, the snippet with the smallest number of words in it. You are given the index positions where these words occur in the document, such as ''word1'': &lt;math&gt;(1, 4, 5)&lt;/math&gt;, ''word2'': &lt;math&gt;(3, 9, 10)&lt;/math&gt;, and ''word3'': &lt;math&gt;(2, 6, 15)&lt;/math&gt;. Each of the lists are in sorted order, as above.


:[[4.53]]. You are given twelve coins. One of them is heavier or lighter than the rest. Identify this coin in just three weighings with a balance scale.
[[4.53|Solution]]


Back to [[Chapter List]]</text>
      <sha1>qtcpibou5k0primasph7xc4mhsqdwlf</sha1>
    </revision>
    <revision>
      <id>449</id>
      <parentid>277</parentid>
      <timestamp>2020-10-01T18:06:49Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <minor/>
      <comment>Protected "[[Chapter 4]]" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="21397">=Sorting=

===Applications of Sorting: Numbers===

:[[4.1]]. The Grinch is given the job of partitioning &lt;math&gt;2n&lt;/math&gt; players into two teams of &lt;math&gt;n&lt;/math&gt; players each. Each player has a numerical rating that measures how good he or she is at the game. The Grinch seeks to divide the players as ''unfairly'' as possible, so as to create the biggest possible talent imbalance between the teams. Show how the Grinch can do the job in &lt;math&gt;O(n log n)&lt;/math&gt; time.
[[4.1|Solution]]


:4.2. For each of the following problems, give an algorithm that finds the desired numbers within the given amount of time. To keep your answers brief, feel free to use algorithms from the book as subroutines. For the example, &lt;math&gt;S = {6, 13, 19, 3, 8}&lt;/math&gt;, 19 - 3 maximizes the difference, while 8 - 6 minimizes the difference.
:(a) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x-y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.
:(b) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''maximizes'' &lt;math&gt;|x - y|&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(1)&lt;/math&gt; worst-case time.
:(c) Let &lt;math&gt;S&lt;/math&gt; be an ''unsorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n log n)&lt;/math&gt; worst-case time.
:(d) Let &lt;math&gt;S&lt;/math&gt; be a ''sorted'' array of &lt;math&gt;n&lt;/math&gt; integers. Give an algorithm that finds the pair &lt;math&gt;x, y \in S&lt;/math&gt; that ''minimizes'' &lt;math&gt;|x - y|&lt;/math&gt;, for &lt;math&gt;x \neq y&lt;/math&gt;. Your algorithm must run in &lt;math&gt;O(n)&lt;/math&gt; worst-case time.


:[[4.3]]. Take a list of &lt;math&gt;2n&lt;/math&gt; real numbers as input. Design an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm that partitions the numbers into &lt;math&gt;n&lt;/math&gt; pairs, with the property that the partition minimizes the maximum sum of a pair. For example, say we are given the numbers (1,3,5,9). The possible partitions are ((1,3),(5,9)), ((1,5),(3,9)), and ((1,9),(3,5)). The pair sums for these partitions are (4,14), (6,12), and (10,8). Thus, the third partition has 10 as its maximum sum, which is the minimum over the three partitions.
[[4.3|Solution]]


:4.4. Assume that we are given &lt;math&gt;n&lt;/math&gt; pairs of items as input, where the first item is a number and the second item is one of three colors (red, blue, or yellow). Further assume that the items are sorted by number. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm to sort the items by color (all reds before all blues before all yellows) such that the numbers for identical colors stay sorted.
:For example: (1,blue), (3,red), (4,blue), (6,yellow), (9,red) should become (3,red), (9,red), (1,blue), (4,blue), (6,yellow).


:[[4.5]]. The ''mode'' of a bag of numbers is the number that occurs most frequently in the set. The set {4, 6, 2, 4, 3, 1} has a mode of 4. Give an efficient and correct algorithm to compute the mode of a bag of &lt;math&gt;n&lt;/math&gt; numbers.
[[4.5|Solution]]


:4.6. Given two sets &lt;math&gt;S_1&lt;/math&gt; and &lt;math&gt;S_2&lt;/math&gt; (each of size &lt;math&gt;n&lt;/math&gt;), and a number &lt;math&gt;x&lt;/math&gt;, describe an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for finding whether there exists a pair of elements, one from &lt;math&gt;S_1&lt;/math&gt; and one from &lt;math&gt;S_2&lt;/math&gt;, that add up to &lt;math&gt;x&lt;/math&gt;. (For partial credit, give a &lt;math&gt;\Theta(n^2)&lt;/math&gt; algorithm for this problem.)


:[[4.7]]. Give an efficient algorithm to take the array of citation counts (each count is a non-negative integer) of a researcher’s papers, and compute the researcher’s &lt;math&gt;h&lt;/math&gt;-index. By definition, a scientist has index &lt;math&gt;h&lt;/math&gt; if &lt;math&gt;h&lt;/math&gt; of his or her &lt;math&gt;n&lt;/math&gt; papers have been cited at least &lt;math&gt;h&lt;/math&gt; times, while the other &lt;math&gt;n-h&lt;/math&gt; papers each have no more than &lt;math&gt;h&lt;/math&gt; citations.
[[4.7|Solution]]


:4.8. Outline a reasonable method of solving each of the following problems. Give the order of the worst-case complexity of your methods.
:(a) You are given a pile of thousands of telephone bills and thousands of checks sent in to pay the bills. Find out who did not pay.
:(b) You are given a printed list containing the title, author, call number, and publisher of all the books in a school library and another list of thirty publishers. Find out how many of the books in the library were published by each company.
:(c) You are given all the book checkout cards used in the campus library during the past year, each of which contains the name of the person who took out the book. Determine how many distinct people checked out at least one book.


:[[4.9]]. Given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers and an integer &lt;math&gt;T&lt;/math&gt;, give an &lt;math&gt;O(n^{k-1}log n)&lt;/math&gt; algorithm to test whether &lt;math&gt;k&lt;/math&gt; of the integers in &lt;math&gt;S&lt;/math&gt; add up to &lt;math&gt;T&lt;/math&gt;.
[[4.9|Solution]]


:4.10. We are given a set of &lt;math&gt;S&lt;/math&gt; containing &lt;math&gt;n&lt;/math&gt; real numbers and a real number &lt;math&gt;x&lt;/math&gt;, and seek efficient algorithms to determine whether two elements of &lt;math&gt;S&lt;/math&gt; exist whose sum is exactly &lt;math&gt;x&lt;/math&gt;.
:(a) Assume that &lt;math&gt;S&lt;/math&gt; is unsorted. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for the problem.
:(b) Assume that &lt;math&gt;S&lt;/math&gt; is sorted. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for the problem.


:[[4.11]]. Design an &lt;math&gt;O(n)&lt;/math&gt; algorithm that, given a list of &lt;math&gt;n&lt;/math&gt; elements, finds all the elements that appear more than &lt;math&gt;n/2&lt;/math&gt; times in the list. Then, design an &lt;math&gt;O(n)&lt;/math&gt; algorithm that, given a list of &lt;math&gt;n&lt;/math&gt; elements, finds all the elements that appear more than &lt;math&gt;n/4&lt;/math&gt; times.
[[4.11|Solution]]

===Applications of Sorting: Intervals and Sets===

:4.12. Give an efficient algorithm to compute the union of sets &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt;, where &lt;math&gt;n = max(|A|, |B|)&lt;/math&gt;. The output should be an array of distinct elements that form the union of the sets.
:(a) Assume that &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; are unsorted arrays. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm for the problem.
:(b) Assume that &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; are sorted arrays. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for the problem.


:[[4.13]]. A camera at the door tracks the entry time &lt;math&gt;a_i&lt;/math&gt; and exit time &lt;math&gt;b_i&lt;/math&gt; (assume &lt;math&gt;b_i &gt; a_i&lt;/math&gt;) for each of &lt;math&gt;n&lt;/math&gt; persons &lt;math&gt;p_i&lt;/math&gt; attending a party. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm that analyzes this data to determine the time when the most people were simultaneously present at the party. You may assume that all entry and exit times are distinct (no ties).
[[4.13|Solution]]


:4.14. Given a list &lt;math&gt;I&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; intervals, specified as &lt;math&gt;(x_i, y_i)&lt;/math&gt; pairs, return a list where the overlapping intervals are merged. For &lt;math&gt;I = {(1, 3),(2, 6),(8, 10),(7, 18)}&lt;/math&gt; the output should be &lt;math&gt;{(1, 6),(7, 18)}&lt;/math&gt;. Your algorithm should run in worst-case &lt;math&gt;O(n log n)&lt;/math&gt; time complexity.


:[[4.15]]. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; intervals on a line, with the &lt;math&gt;i&lt;/math&gt;th interval described by its left and right endpoints &lt;math&gt;(l_i, r_i)&lt;/math&gt;. Give an &lt;math&gt;O(n log n)&lt;/math&gt; algorithm to identify a point &lt;math&gt;p&lt;/math&gt; on the line that is in the largest number of intervals.
:As an example, for &lt;math&gt;S = {(10, 40),(20, 60),(50, 90),(15, 70)}&lt;/math&gt; no point exists in all four intervals, but &lt;math&gt;p = 50&lt;/math&gt; is an example of a point in three intervals. You can assume an endpoint counts as being in its interval.
[[4.15|Solution]]


:4.16. You are given a set &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; segments on the line, where segment &lt;math&gt;S_i&lt;/math&gt; ranges from &lt;math&gt;l_i&lt;/math&gt; to &lt;math&gt;r_i&lt;/math&gt;. Give an efficient algorithm to select the fewest number of segments whose union completely covers the interval from 0 to &lt;math&gt;m&lt;/math&gt;.

===Heaps===

:[[4.17]]. Devise an algorithm for finding the &lt;math&gt;k&lt;/math&gt; smallest elements of an unsorted set of &lt;math&gt;n&lt;/math&gt; integers in &lt;math&gt;O(n + k log n)&lt;/math&gt;.
[[4.17|Solution]]


:4.18. Give an &lt;math&gt;O(n log k)&lt;/math&gt;-time algorithm that merges &lt;math&gt;k&lt;/math&gt; sorted lists with a total of &lt;math&gt;n&lt;/math&gt; elements into one sorted list. (Hint: use a heap to speed up the obvious &lt;math&gt;O(know)&lt;/math&gt;-time algorithm).


:[[4.19]]. You wish to store a set of &lt;math&gt;n&lt;/math&gt; numbers in either a max-heap or a sorted array. For each application below, state which data structure is better, or if it does not matter. Explain your answers.
:(a) Find the maximum element quickly.
:(b) Delete an element quickly.
:(c) Form the structure quickly.
:(d) Find the minimum element quickly.
[[4.19|Solution]]


:4.20. (a) Give an efficient algorithm to find the second-largest key among &lt;math&gt;n&lt;/math&gt; keys. You can do better than &lt;math&gt;2n - 3&lt;/math&gt; comparisons.
:(b) Then, give an efficient algorithm to find the third-largest key among &lt;math&gt;n&lt;/math&gt; keys. How many key comparisons does your algorithm do in the worst case? Must your algorithm determine which key is largest and second-largest in the process?

===Quicksort===

:[[4.21]]. Use the partitioning idea of quicksort to give an algorithm that finds the median element of an array of &lt;math&gt;n&lt;/math&gt; integers in expected &lt;math&gt;O(n)&lt;/math&gt; time. (Hint: must you look at both sides of the partition?)
[[4.21|Solution]]


:4.22. The ''median'' of a set of &lt;math&gt;n&lt;/math&gt; values is the &lt;math&gt;[n/2]&lt;/math&gt;th smallest value.
:(a) Suppose quicksort always pivoted on the median of the current sub-array. How many comparisons would quicksort make then in the worst case?
:(b) Suppose quicksort always pivoted on the &lt;math&gt;[n/3]&lt;/math&gt;th smallest value of the current sub-array. How many comparisons would be made then in the worst case?


:[[4.23]]. Suppose an array &lt;math&gt;A&lt;/math&gt; consists of &lt;math&gt;n&lt;/math&gt; elements, each of which is ''red'', ''white'', or ''blue'. We seek to sort the elements so that all the ''reds'' come before all the ''whites'', which come before all the ''blues''. The only operations permitted on the keys are:
::• ''Examine''(&lt;math&gt;A,i&lt;/math&gt;) – report the color of the &lt;math&gt;i&lt;/math&gt;th element of &lt;math&gt;A&lt;/math&gt;.
::• ''Swap''(&lt;math&gt;A,i,j&lt;/math&gt;) – swap the &lt;math&gt;i&lt;/math&gt;th element of &lt;math&gt;A&lt;/math&gt; with the &lt;math&gt;j&lt;/math&gt;th element.
:Find a correct and efficient algorithm for red–white–blue sorting. There is a linear-time solution.
[[4.23|Solution]]


:4.24. Give an efficient algorithm to rearrange an array of &lt;math&gt;n&lt;/math&gt; keys so that all the negative keys precede all the non-negative keys. Your algorithm must be in-place, meaning you cannot allocate another array to temporarily hold the items. How fast is your algorithm?


:[[4.25]]. Consider a given pair of different elements in an input array to be sorted, say &lt;math&gt;z_i&lt;/math&gt; and &lt;math&gt;z_j&lt;/math&gt; . What is the most number of times &lt;math&gt;z_i&lt;/math&gt; and &lt;math&gt;z_j&lt;/math&gt; might be compared with each other during an execution of quicksort?
[[4.25|Solution]]


:4.26. Define the recursion depth of quicksort as the maximum number of successive recursive calls it makes before hitting the base case. What are the minimum and maximum possible recursion depths for randomized quicksort?


:[[4.27]]. Suppose you are given a permutation &lt;math&gt;p&lt;/math&gt; of the integers 1 to &lt;math&gt;n&lt;/math&gt;, and seek to sort them to be in increasing order &lt;math&gt;[1, . . . , n]&lt;/math&gt;. The only operation at your disposal is ''reverse''&lt;math&gt;(p,i,j)&lt;/math&gt;, which reverses the elements of a subsequence &lt;math&gt;p_i, . . . , p_j&lt;/math&gt; in the permutation. For the permutation [1, 4, 3, 2, 5] one reversal (of the second through fourth elements) suffices to sort.
:• Show that it is possible to sort any permutation using &lt;math&gt;O(n)&lt;/math&gt; reversals.
:• Now suppose that the cost of ''reverse''&lt;math&gt;(p,i,j)&lt;/math&gt; is equal to its length, the number of elements in the range, &lt;math&gt;|j - i| + 1&lt;/math&gt;. Design an algorithm that sorts &lt;math&gt;p&lt;/math&gt; in &lt;math&gt;O(n log^2 n)&lt;/math&gt; cost. Analyze the running time and cost of your algorithm and prove correctness.
[[4.27|Solution]]

===Mergesort===

:4.28. Consider the following modification to merge sort: divide the input array into thirds (rather than halves), recursively sort each third, and finally combine the results using a three-way merge subroutine. What is the worst-case running time of this modified merge sort?


:[[4.29]]. Suppose you are given &lt;math&gt;k&lt;/math&gt; sorted arrays, each with &lt;math&gt;n&lt;/math&gt; elements, and you want to combine them into a single sorted array of &lt;math&gt;kn&lt;/math&gt; elements. One approach is to use the merge subroutine repeatedly, merging the first two arrays, then merging the result with the third array, then with the fourth array, and so on until you merge in the &lt;math&gt;k&lt;/math&gt;th and final input array. What is the running time?
[[4.29|Solution]]


:4.30. Consider again the problem of merging &lt;math&gt;k&lt;/math&gt; sorted length-&lt;math&gt;n&lt;/math&gt; arrays into a single sorted length-&lt;math&gt;kn&lt;/math&gt; array. Consider the algorithm that first divides the &lt;math&gt;k&lt;/math&gt; arrays into &lt;math&gt;k/2&lt;/math&gt; pairs of arrays, and uses the merge subroutine to combine each pair, resulting in &lt;math&gt;k/2&lt;/math&gt; sorted length-&lt;math&gt;2n&lt;/math&gt; arrays. The algorithm repeats this step until there is only one length-&lt;math&gt;know&lt;/math&gt; sorted array. What is the running time as a function of &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;?

===Other Sorting Alogrithims===

:[[4.31]]. Stable sorting algorithms leave equal-key items in the same relative order as in the original permutation. Explain what must be done to ensure that mergesort is a stable sorting algorithm.
[[4.31|Solution]]


:4.32. Wiggle sort: Given an unsorted array &lt;math&gt;A&lt;/math&gt;, reorder it such that &lt;math&gt;A[0] &lt; A[1] &gt; A[2] &lt; A[3] . . . .&lt;/math&gt; For example, one possible answer for input [3, 1, 4, 2, 6, 5] is [1, 3, 2, 5, 4, 6]. Can you do it in &lt;math&gt;O(n)&lt;/math&gt; time using only &lt;math&gt;O(1)&lt;/math&gt; space?


:[[4.33]]. Show that &lt;math&gt;n&lt;/math&gt; positive integers in the range 1 to &lt;math&gt;k&lt;/math&gt; can be sorted in &lt;math&gt;O(n log k)&lt;/math&gt; time. The interesting case is when &lt;math&gt;k \ll n&lt;/math&gt;.
[[4.33|Solution]]


:4.34. Consider a sequence &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers with many duplications, such that the number of distinct integers in &lt;math&gt;S&lt;/math&gt; is &lt;math&gt;O(log n)&lt;/math&gt;. Give an &lt;math&gt;O(n log log n)&lt;/math&gt; worst-case time algorithm to sort such sequences.


:[[4.35]]. Let &lt;math&gt;A[1..n]&lt;/math&gt; be an array such that the first &lt;math&gt;n -
\sqrt n&lt;/math&gt; elements are already sorted (though we know nothing about the remaining elements). Give an algorithm that sorts &lt;math&gt;A&lt;/math&gt; in substantially better than &lt;math&gt;n log n&lt;/math&gt; steps.
[[4.35|Solution]]


:4.36. Assume that the array &lt;math&gt;A[1..n]&lt;/math&gt; only has numbers from &lt;math&gt;{1, . . . , n^2}&lt;/math&gt; but that at most &lt;math&gt;log log n&lt;/math&gt; of these numbers ever appear. Devise an algorithm that sorts &lt;math&gt;A&lt;/math&gt; in substantially less than &lt;math&gt;O(n log n)&lt;/math&gt;.


:[[4.37]]. Consider the problem of sorting a sequence of &lt;math&gt;n&lt;/math&gt; 0’s and 1’s using comparisons. For each comparison of two values &lt;math&gt;x&lt;/math&gt; and &lt;math&gt;y&lt;/math&gt;, the algorithm learns which of &lt;math&gt;x &lt; y, x = y&lt;/math&gt;, or &lt;math&gt;x &gt; y&lt;/math&gt; holds.
:(a) Give an algorithm to sort in &lt;math&gt;n - 1&lt;/math&gt; comparisons in the worst case. Show that your algorithm is optimal.
:(b) Give an algorithm to sort in &lt;math&gt;2n/3&lt;/math&gt; comparisons in the average case (assuming each of the &lt;math&gt;n&lt;/math&gt; inputs is 0 or 1 with equal probability). Show that your algorithm is optimal.
[[4.37|Solution]]


:4.38. Let &lt;math&gt;P&lt;/math&gt; be a simple, but not necessarily convex, &lt;math&gt;n&lt;/math&gt;-sided polygon and &lt;math&gt;q&lt;/math&gt; an arbitrary point not necessarily in &lt;math&gt;P&lt;/math&gt;. Design an efficient algorithm to find a line segment originating from &lt;math&gt;q&lt;/math&gt; that intersects the maximum number of edges of &lt;math&gt;P&lt;/math&gt;. 
:In other words, if standing at point &lt;math&gt;q&lt;/math&gt;, in what direction should you aim a gun so the bullet will go through the largest number of walls. A bullet through a vertex of &lt;math&gt;P&lt;/math&gt; gets credit for only one wall. An &lt;math&gt;O(n log n)&lt;/math&gt; algorithm is possible.

===Lower Bounds===

:[[4.39]]. In one of my research papers [Ski88], I discovered a comparison-based sorting algorithm that runs in &lt;math&gt;O(n log(\sqrt n))&lt;/math&gt;. Given the existence of an &lt;math&gt;\Omega(n log n)&lt;/math&gt; lower bound for sorting, how can this be possible?
[[4.39|Solution]]


:4.40. Mr. B. C. Dull claims to have developed a new data structure for priority queues that supports the operations ''Insert'', ''Maximum'', and ''Extract-Max''—all in &lt;math&gt;O(1)&lt;/math&gt; worst-case time. Prove that he is mistaken. (Hint: the argument does not involve a lot of gory details—just think about what this would imply about the &lt;math&gt;\Omega (n log n)&lt;/math&gt; lower bound for sorting.)

===Searching===

:[[4.41]]. A company database consists of 10,000 sorted names, 40% of whom are known as good customers and who together account for 60% of the accesses to the database. There are two data structure options to consider for representing the database:
:• Put all the names in a single array and use binary search.
:• Put the good customers in one array and the rest of them in a second array. Only if we do not find the query name on a binary search of the first array do we do a binary search of the second array.
:Demonstrate which option gives better expected performance. Does this change if linear search on an unsorted array is used instead of binary search for both options?
[[4.41|Solution]]


:4.42. A ''Ramanujan number'' can be written two different ways as the sum of two cubes—meaning there exist distinct positive integers &lt;math&gt;a, b, c&lt;/math&gt;, and &lt;math&gt;d&lt;/math&gt; such that &lt;math&gt;a^3 + b^3 = c^3 + d^3&lt;/math&gt;. For example, 1729 is a Ramanujan number because &lt;math&gt;1729 = 1^3 + 12^3 = 9^3 + 10^3&lt;/math&gt;.
:(a) Give an efficient algorithm to test whether a given single integer &lt;math&gt;n&lt;/math&gt; is a Ramanujan number, with an analysis of the algorithm’s complexity.
:(b) Now give an efficient algorithm to generate all the Ramanujan numbers between 1 and &lt;math&gt;n&lt;/math&gt;, with an analysis of its complexity.

===Implementaion Challenges===

:[[4.43]]. Consider an n×n array &lt;math&gt;A&lt;/math&gt; containing integer elements (positive, negative, and zero). Assume that the elements in each row of &lt;math&gt;A&lt;/math&gt; are in strictly increasing order, and the elements of each column of &lt;math&gt;A&lt;/math&gt; are in strictly decreasing order. (Hence there cannot be two zeros in the same row or the same column.) Describe an efficient algorithm that counts the number of occurrences of the element 0 in &lt;math&gt;A&lt;/math&gt;. Analyze its running time.
[[4.43|Solution]]


:4.44. Implement versions of several different sorting algorithms, such as selection sort, insertion sort, heapsort, mergesort, and quicksort. Conduct experiments to assess the relative performance of these algorithms in a simple application that reads a large text file and reports exactly one instance of each word that appears within it. This application can be efficiently implemented by sorting all the words that occur in the text and then passing through the sorted sequence to identify one instance of each distinct word. Write a brief report with your conclusions.


:[[4.45]]. Implement an external sort, which uses intermediate files to sort files bigger than main memory. Mergesort is a good algorithm to base such an implementation on. Test your program both on files with small records and on files with large records.
[[4.45|Solution]]


:4.46. Design and implement a parallel sorting algorithm that distributes data across several processors. An appropriate variation of mergesort is a likely candidate. Measure the speedup of this algorithm as the number of processors increases. Then compare the execution time to that of a purely sequential mergesort implementation. What are your experiences?

===Interview Problems===

:[[4.47]]. If you are given a million integers to sort, what algorithm would you use to sort them? How much time and memory would that consume?
[[4.47|Solution]]


:4.48. Describe advantages and disadvantages of the most popular sorting algorithms.


:[[4.49]]. Implement an algorithm that takes an input array and returns only the unique elements in it.
[[4.49|Solution]]


:4.50. You have a computer with only 4 GB of main memory. How do you use it to sort a large file of 500 GB that is on disk?


:[[4.51]]. Design a stack that supports push, pop, and retrieving the minimum element in constant time.
[[4.51|Solution]]


:4.52. Given a search string of three words, find the smallest snippet of the document that contains all three of the search words—that is, the snippet with the smallest number of words in it. You are given the index positions where these words occur in the document, such as ''word1'': &lt;math&gt;(1, 4, 5)&lt;/math&gt;, ''word2'': &lt;math&gt;(3, 9, 10)&lt;/math&gt;, and ''word3'': &lt;math&gt;(2, 6, 15)&lt;/math&gt;. Each of the lists are in sorted order, as above.


:[[4.53]]. You are given twelve coins. One of them is heavier or lighter than the rest. Identify this coin in just three weighings with a balance scale.
[[4.53|Solution]]


Back to [[Chapter List]]</text>
      <sha1>qtcpibou5k0primasph7xc4mhsqdwlf</sha1>
    </revision>
  </page>
  <page>
    <title>Chapter 5</title>
    <ns>0</ns>
    <id>8</id>
    <revision>
      <id>17</id>
      <timestamp>2020-08-23T19:34:48Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Problems   Back to [[Chapter List]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="35">Problems


Back to [[Chapter List]]</text>
      <sha1>95722ndl4ewzic1ak6z8g4auy0tqhc6</sha1>
    </revision>
    <revision>
      <id>112</id>
      <parentid>17</parentid>
      <timestamp>2020-09-07T18:16:13Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="282">=Divide and Conquer=

===Binary Search===

:[[5.1]]


:5.2


:[[5.3]]


:5.4


:[[5.5]]


:5.6


:[[5.7]]


===Divide and Conquer Algorithms===

:5.8


:[[5.9]]


:5.10


:[[5.11]]


===Recurrence Relations===

:5.12


:[5.13]]


:5.14


:[[5.15]]


:5.16


Back to [[Chapter List]]</text>
      <sha1>squ8sr8zxznm7u04djh0xe5eees2z4i</sha1>
    </revision>
    <revision>
      <id>113</id>
      <parentid>112</parentid>
      <timestamp>2020-09-07T18:16:27Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Recurrence Relations */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="283">=Divide and Conquer=

===Binary Search===

:[[5.1]]


:5.2


:[[5.3]]


:5.4


:[[5.5]]


:5.6


:[[5.7]]


===Divide and Conquer Algorithms===

:5.8


:[[5.9]]


:5.10


:[[5.11]]


===Recurrence Relations===

:5.12


:[[5.13]]


:5.14


:[[5.15]]


:5.16


Back to [[Chapter List]]</text>
      <sha1>8q5ku51nxfa0y6jwzk0vq13th7ngdbo</sha1>
    </revision>
    <revision>
      <id>251</id>
      <parentid>113</parentid>
      <timestamp>2020-09-14T18:33:24Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Binary Search */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="3127">=Divide and Conquer=

===Binary Search===

:[[5.1]]. Suppose you are given a sorted array &lt;math&gt;A&lt;/math&gt; of size n that has been circularly shifted &lt;math&gt;k&lt;/math&gt; positions to the right. For example, [35, 42, 5, 15, 27, 29] is a sorted array that has been circularly shifted &lt;math&gt;k = 2&lt;/math&gt; positions, while [27, 29, 35, 42, 5, 15] has been shifted &lt;math&gt;k = 4&lt;/math&gt; positions.
:• Suppose you know what &lt;math&gt;k&lt;/math&gt; is. Give an &lt;math&gt;O(1)&lt;/math&gt; algorithm to find the largest number in &lt;math&gt;A&lt;/math&gt;.
:• Suppose you do not know what &lt;math&gt;k&lt;/math&gt; is. Give an &lt;math&gt;O(lg n)&lt;/math&gt; algorithm to find the largest number in &lt;math&gt;A&lt;/math&gt;. For partial credit, you may give an &lt;math&gt;O(n)&lt;/math&gt; algorithm.
[[5.1|Solution]]


:5.2. A sorted array of size n contains distinct integers between &lt;math&gt;1&lt;/math&gt; and &lt;math&gt;n + 1&lt;/math&gt; , with one element missing. Give an &lt;math&gt;O(log n)&lt;/math&gt; algorithm to find the missing integer, without using any extra space.


:[[5.3]] Consider the numerical Twenty Questions game. In this game, the first player thinks of a number in the range 1 to &lt;math&gt;n&lt;/math&gt;. The second player has to figure out this number by asking the fewest number of true/false questions. Assume that nobody cheats.
:(a) What is an optimal strategy if &lt;math&gt;n&lt;/math&gt; in known?
:(b) What is a good strategy if &lt;math&gt;n&lt;/math&gt; is not known?
[[5.3|Solution]]


:5.4. You are given a unimodal array of &lt;math&gt;n&lt;/math&gt; distinct elements, meaning that its entries are in increasing order up until its maximum element, after which its elements are in decreasing order. Give an algorithm to compute the maximum element of a unimodal array that runs in &lt;math&gt;O(log n)&lt;/math&gt; time.


:[[5.5]]. Suppose that you are given a sorted sequence of distinct integers &lt;math&gt;[a_1, a_2, . . . , a_n]&lt;/math&gt;. Give an &lt;math&gt;O(lg n)&lt;/math&gt; algorithm to determine whether there exists an index &lt;math&gt;i&lt;/math&gt; such that &lt;math&gt;a_i = i&lt;/math&gt;. For example, in [-10, -3, 3, 5, 7], &lt;math&gt;a_3 = 3&lt;/math&gt;. In [2, 3, 4, 5, 6, 7], there is no such &lt;math&gt;i&lt;/math&gt;.
[[5.5|Solution]]


:5.6. Suppose that you are given a sorted sequence of distinct integers &lt;math&gt;a = [a_1, a_2, . . . , a_n]&lt;/math&gt;, drawn from 1 to &lt;math&gt;m&lt;/math&gt; where &lt;math&gt;n &lt; m&lt;/math&gt;. Give an &lt;math&gt;O(lg n)&lt;/math&gt; algorithm to find an integer &lt;math&gt;\leq m&lt;/math&gt; that is not present in &lt;math&gt;a&lt;/math&gt;. For full credit, find the smallest such integer &lt;math&gt;x&lt;/math&gt; such that &lt;math&gt;1 \leq x \leq m&lt;/math&gt;.


:[[5.7]]. Let &lt;math&gt;M&lt;/math&gt; be an &lt;math&gt;n * m&lt;/math&gt; integer matrix in which the entries of each row are sorted in increasing order (from left to right) and the entries in each column are in increasing order (from top to bottom). Give an efficient algorithm to find the position of an integer &lt;math&gt;x&lt;/math&gt; in &lt;math&gt;M&lt;/math&gt;, or to determine that &lt;math&gt;x&lt;/math&gt; is not there. How many comparisons of &lt;math&gt;x&lt;/math&gt; with matrix entries does your algorithm use in worst case?
[[5.7|Solution]]

===Divide and Conquer Algorithms===

:5.8


:[[5.9]]


:5.10


:[[5.11]]


===Recurrence Relations===

:5.12


:[[5.13]]


:5.14


:[[5.15]]


:5.16


Back to [[Chapter List]]</text>
      <sha1>hhla1l4ukrtuj5reiuzhp7eerc7hj5o</sha1>
    </revision>
    <revision>
      <id>252</id>
      <parentid>251</parentid>
      <timestamp>2020-09-14T18:40:20Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Divide and Conquer Algorithms */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="4639">=Divide and Conquer=

===Binary Search===

:[[5.1]]. Suppose you are given a sorted array &lt;math&gt;A&lt;/math&gt; of size n that has been circularly shifted &lt;math&gt;k&lt;/math&gt; positions to the right. For example, [35, 42, 5, 15, 27, 29] is a sorted array that has been circularly shifted &lt;math&gt;k = 2&lt;/math&gt; positions, while [27, 29, 35, 42, 5, 15] has been shifted &lt;math&gt;k = 4&lt;/math&gt; positions.
:• Suppose you know what &lt;math&gt;k&lt;/math&gt; is. Give an &lt;math&gt;O(1)&lt;/math&gt; algorithm to find the largest number in &lt;math&gt;A&lt;/math&gt;.
:• Suppose you do not know what &lt;math&gt;k&lt;/math&gt; is. Give an &lt;math&gt;O(lg n)&lt;/math&gt; algorithm to find the largest number in &lt;math&gt;A&lt;/math&gt;. For partial credit, you may give an &lt;math&gt;O(n)&lt;/math&gt; algorithm.
[[5.1|Solution]]


:5.2. A sorted array of size n contains distinct integers between &lt;math&gt;1&lt;/math&gt; and &lt;math&gt;n + 1&lt;/math&gt; , with one element missing. Give an &lt;math&gt;O(log n)&lt;/math&gt; algorithm to find the missing integer, without using any extra space.


:[[5.3]] Consider the numerical Twenty Questions game. In this game, the first player thinks of a number in the range 1 to &lt;math&gt;n&lt;/math&gt;. The second player has to figure out this number by asking the fewest number of true/false questions. Assume that nobody cheats.
:(a) What is an optimal strategy if &lt;math&gt;n&lt;/math&gt; in known?
:(b) What is a good strategy if &lt;math&gt;n&lt;/math&gt; is not known?
[[5.3|Solution]]


:5.4. You are given a unimodal array of &lt;math&gt;n&lt;/math&gt; distinct elements, meaning that its entries are in increasing order up until its maximum element, after which its elements are in decreasing order. Give an algorithm to compute the maximum element of a unimodal array that runs in &lt;math&gt;O(log n)&lt;/math&gt; time.


:[[5.5]]. Suppose that you are given a sorted sequence of distinct integers &lt;math&gt;[a_1, a_2, . . . , a_n]&lt;/math&gt;. Give an &lt;math&gt;O(lg n)&lt;/math&gt; algorithm to determine whether there exists an index &lt;math&gt;i&lt;/math&gt; such that &lt;math&gt;a_i = i&lt;/math&gt;. For example, in [-10, -3, 3, 5, 7], &lt;math&gt;a_3 = 3&lt;/math&gt;. In [2, 3, 4, 5, 6, 7], there is no such &lt;math&gt;i&lt;/math&gt;.
[[5.5|Solution]]


:5.6. Suppose that you are given a sorted sequence of distinct integers &lt;math&gt;a = [a_1, a_2, . . . , a_n]&lt;/math&gt;, drawn from 1 to &lt;math&gt;m&lt;/math&gt; where &lt;math&gt;n &lt; m&lt;/math&gt;. Give an &lt;math&gt;O(lg n)&lt;/math&gt; algorithm to find an integer &lt;math&gt;\leq m&lt;/math&gt; that is not present in &lt;math&gt;a&lt;/math&gt;. For full credit, find the smallest such integer &lt;math&gt;x&lt;/math&gt; such that &lt;math&gt;1 \leq x \leq m&lt;/math&gt;.


:[[5.7]]. Let &lt;math&gt;M&lt;/math&gt; be an &lt;math&gt;n * m&lt;/math&gt; integer matrix in which the entries of each row are sorted in increasing order (from left to right) and the entries in each column are in increasing order (from top to bottom). Give an efficient algorithm to find the position of an integer &lt;math&gt;x&lt;/math&gt; in &lt;math&gt;M&lt;/math&gt;, or to determine that &lt;math&gt;x&lt;/math&gt; is not there. How many comparisons of &lt;math&gt;x&lt;/math&gt; with matrix entries does your algorithm use in worst case?
[[5.7|Solution]]

===Divide and Conquer Algorithms===

:5.8. Given two sorted arrays &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; of size &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;m&lt;/math&gt; respectively, find the median of the &lt;math&gt;n + m&lt;/math&gt; elements. The overall run time complexity should be &lt;math&gt;O(log(m + n))&lt;/math&gt;.


:[[5.9]]. The largest subrange problem, discussed in Section 5.6, takes an array &lt;math&gt;A&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; numbers, and asks for the index pair &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; that maximizes &lt;math&gt;S = \sum_{k=1}^j A[k]&lt;/math&gt;. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for largest subrange.
[[5.9|Solution]]


:5.10. We are given &lt;math&gt;n&lt;/math&gt; wooden sticks, each of integer length, where the &lt;math&gt;i&lt;/math&gt;th piece has length &lt;math&gt;L[i]&lt;/math&gt;. We seek to cut them so that we end up with &lt;math&gt;k&lt;/math&gt; pieces of exactly the same length, in addition to other fragments. Furthermore, we want these &lt;math&gt;k&lt;/math&gt; pieces to be as large as possible.
:(a) Given four wood sticks, of lengths &lt;math&gt;L = {10, 6, 5, 3}&lt;/math&gt;, what are the largest sized pieces you can get for &lt;math&gt;k = 4&lt;/math&gt;? (Hint: the answer is not 3).
:(b) Give a correct and efficient algorithm that, for a given &lt;math&gt;L&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;, returns the maximum possible length of the &lt;math&gt;k&lt;/math&gt; equal pieces cut from the initial &lt;math&gt;n&lt;/math&gt; sticks.


:[[5.11]]. Extend the convolution-based string-matching algorithm described in the text to the case of pattern matching with wildcard characters “*”, which match any character. For example, “sh*t” should match both “shot” and “shut”.
[[5.11|Solution]]

===Recurrence Relations===

:5.12


:[[5.13]]


:5.14


:[[5.15]]


:5.16


Back to [[Chapter List]]</text>
      <sha1>03e9ir3uii6xaqug7dyyhpuyktps4vw</sha1>
    </revision>
    <revision>
      <id>253</id>
      <parentid>252</parentid>
      <timestamp>2020-09-14T18:49:23Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Recurrence Relations */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="6440">=Divide and Conquer=

===Binary Search===

:[[5.1]]. Suppose you are given a sorted array &lt;math&gt;A&lt;/math&gt; of size n that has been circularly shifted &lt;math&gt;k&lt;/math&gt; positions to the right. For example, [35, 42, 5, 15, 27, 29] is a sorted array that has been circularly shifted &lt;math&gt;k = 2&lt;/math&gt; positions, while [27, 29, 35, 42, 5, 15] has been shifted &lt;math&gt;k = 4&lt;/math&gt; positions.
:• Suppose you know what &lt;math&gt;k&lt;/math&gt; is. Give an &lt;math&gt;O(1)&lt;/math&gt; algorithm to find the largest number in &lt;math&gt;A&lt;/math&gt;.
:• Suppose you do not know what &lt;math&gt;k&lt;/math&gt; is. Give an &lt;math&gt;O(lg n)&lt;/math&gt; algorithm to find the largest number in &lt;math&gt;A&lt;/math&gt;. For partial credit, you may give an &lt;math&gt;O(n)&lt;/math&gt; algorithm.
[[5.1|Solution]]


:5.2. A sorted array of size n contains distinct integers between &lt;math&gt;1&lt;/math&gt; and &lt;math&gt;n + 1&lt;/math&gt; , with one element missing. Give an &lt;math&gt;O(log n)&lt;/math&gt; algorithm to find the missing integer, without using any extra space.


:[[5.3]] Consider the numerical Twenty Questions game. In this game, the first player thinks of a number in the range 1 to &lt;math&gt;n&lt;/math&gt;. The second player has to figure out this number by asking the fewest number of true/false questions. Assume that nobody cheats.
:(a) What is an optimal strategy if &lt;math&gt;n&lt;/math&gt; in known?
:(b) What is a good strategy if &lt;math&gt;n&lt;/math&gt; is not known?
[[5.3|Solution]]


:5.4. You are given a unimodal array of &lt;math&gt;n&lt;/math&gt; distinct elements, meaning that its entries are in increasing order up until its maximum element, after which its elements are in decreasing order. Give an algorithm to compute the maximum element of a unimodal array that runs in &lt;math&gt;O(log n)&lt;/math&gt; time.


:[[5.5]]. Suppose that you are given a sorted sequence of distinct integers &lt;math&gt;[a_1, a_2, . . . , a_n]&lt;/math&gt;. Give an &lt;math&gt;O(lg n)&lt;/math&gt; algorithm to determine whether there exists an index &lt;math&gt;i&lt;/math&gt; such that &lt;math&gt;a_i = i&lt;/math&gt;. For example, in [-10, -3, 3, 5, 7], &lt;math&gt;a_3 = 3&lt;/math&gt;. In [2, 3, 4, 5, 6, 7], there is no such &lt;math&gt;i&lt;/math&gt;.
[[5.5|Solution]]


:5.6. Suppose that you are given a sorted sequence of distinct integers &lt;math&gt;a = [a_1, a_2, . . . , a_n]&lt;/math&gt;, drawn from 1 to &lt;math&gt;m&lt;/math&gt; where &lt;math&gt;n &lt; m&lt;/math&gt;. Give an &lt;math&gt;O(lg n)&lt;/math&gt; algorithm to find an integer &lt;math&gt;\leq m&lt;/math&gt; that is not present in &lt;math&gt;a&lt;/math&gt;. For full credit, find the smallest such integer &lt;math&gt;x&lt;/math&gt; such that &lt;math&gt;1 \leq x \leq m&lt;/math&gt;.


:[[5.7]]. Let &lt;math&gt;M&lt;/math&gt; be an &lt;math&gt;n * m&lt;/math&gt; integer matrix in which the entries of each row are sorted in increasing order (from left to right) and the entries in each column are in increasing order (from top to bottom). Give an efficient algorithm to find the position of an integer &lt;math&gt;x&lt;/math&gt; in &lt;math&gt;M&lt;/math&gt;, or to determine that &lt;math&gt;x&lt;/math&gt; is not there. How many comparisons of &lt;math&gt;x&lt;/math&gt; with matrix entries does your algorithm use in worst case?
[[5.7|Solution]]

===Divide and Conquer Algorithms===

:5.8. Given two sorted arrays &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; of size &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;m&lt;/math&gt; respectively, find the median of the &lt;math&gt;n + m&lt;/math&gt; elements. The overall run time complexity should be &lt;math&gt;O(log(m + n))&lt;/math&gt;.


:[[5.9]]. The largest subrange problem, discussed in Section 5.6, takes an array &lt;math&gt;A&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; numbers, and asks for the index pair &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; that maximizes &lt;math&gt;S = \sum_{k=1}^j A[k]&lt;/math&gt;. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for largest subrange.
[[5.9|Solution]]


:5.10. We are given &lt;math&gt;n&lt;/math&gt; wooden sticks, each of integer length, where the &lt;math&gt;i&lt;/math&gt;th piece has length &lt;math&gt;L[i]&lt;/math&gt;. We seek to cut them so that we end up with &lt;math&gt;k&lt;/math&gt; pieces of exactly the same length, in addition to other fragments. Furthermore, we want these &lt;math&gt;k&lt;/math&gt; pieces to be as large as possible.
:(a) Given four wood sticks, of lengths &lt;math&gt;L = {10, 6, 5, 3}&lt;/math&gt;, what are the largest sized pieces you can get for &lt;math&gt;k = 4&lt;/math&gt;? (Hint: the answer is not 3).
:(b) Give a correct and efficient algorithm that, for a given &lt;math&gt;L&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;, returns the maximum possible length of the &lt;math&gt;k&lt;/math&gt; equal pieces cut from the initial &lt;math&gt;n&lt;/math&gt; sticks.


:[[5.11]]. Extend the convolution-based string-matching algorithm described in the text to the case of pattern matching with wildcard characters “*”, which match any character. For example, “sh*t” should match both “shot” and “shut”.
[[5.11|Solution]]

===Recurrence Relations===

:5.12. In Section 5.3, it is asserted that any polynomial can be represented by a recurrence. Find a recurrence relation that represents the polynomial &lt;math&gt;a_n = n^2&lt;/math&gt;.


:[[5.13]]. Suppose you are choosing between the following three algorithms:
:• Algorithm &lt;math&gt;A&lt;/math&gt; solves problems by dividing them into five subproblems of half the size, recursively solving each subproblem, and then combining the solutions in linear time.
:• Algorithm &lt;math&gt;B&lt;/math&gt; solves problems of size &lt;math&gt;n&lt;/math&gt; by recursively solving two subproblems of size &lt;math&gt;n - 1&lt;/math&gt; and then combining the solutions in constant time.
:• Algorithm &lt;math&gt;C&lt;/math&gt; solves problems of size &lt;math&gt;n&lt;/math&gt; by dividing them into nine subproblems of size &lt;math&gt;n/3&lt;/math&gt;, recursively solving each subproblem, and then combining the solutions in &lt;math&gt;\Theta(n^2)&lt;/math&gt; time.
:What are the running times of each of these algorithms (in big O notation), and which would you choose?
[[5.13|Solution]]


:5.14. Solve the following recurrence relations and give a &lt;math&gt;\Theta&lt;/math&gt; bound for each of them:
:(a) &lt;math&gt;T(n) = 2T(n/3) + 1&lt;/math&gt;
:(b) &lt;math&gt;T(n) = 5T(n/4) + n&lt;/math&gt;
:(c) &lt;math&gt;T(n) = 7T(n/7) + n&lt;/math&gt;
:(d) &lt;math&gt;T(n) = 9T(n/3) + n^2&lt;/math&gt;


:[[5.15]]. Use the master theorem to solve the following recurrence relations:
:(a) &lt;math&gt;T(n) = 64T(n/4) + n^4&lt;/math&gt;
:(b) &lt;math&gt;T(n) = 64T(n/4) + n^3&lt;/math&gt;
:(c) &lt;math&gt;T(n) = 64T(n/4) + 128&lt;/math&gt;
[[5.15|Solution]]


:5.16. Give asymptotically tight upper (Big Oh) bounds for &lt;math&gt;T(n)&lt;/math&gt; in each of the following recurrences. Justify your solutions by naming the particular case of the master theorem, by iterating the recurrence, or by using the substitution method:
:(a) &lt;math&gt;T(n) = T(n - 2) + 1&lt;/math&gt;.
:(b) &lt;math&gt;T(n) = 2T(n/2) + n lg^2 n&lt;/math&gt;.
:(c) &lt;math&gt;T(n) = 9T(n/4) + n^2&lt;/math&gt;.


Back to [[Chapter List]]</text>
      <sha1>j80wcaqsafxoe1diekhlxvifmyrp7x9</sha1>
    </revision>
    <revision>
      <id>450</id>
      <parentid>253</parentid>
      <timestamp>2020-10-01T18:08:24Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <minor/>
      <comment>Protected "[[Chapter 5]]" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="6440">=Divide and Conquer=

===Binary Search===

:[[5.1]]. Suppose you are given a sorted array &lt;math&gt;A&lt;/math&gt; of size n that has been circularly shifted &lt;math&gt;k&lt;/math&gt; positions to the right. For example, [35, 42, 5, 15, 27, 29] is a sorted array that has been circularly shifted &lt;math&gt;k = 2&lt;/math&gt; positions, while [27, 29, 35, 42, 5, 15] has been shifted &lt;math&gt;k = 4&lt;/math&gt; positions.
:• Suppose you know what &lt;math&gt;k&lt;/math&gt; is. Give an &lt;math&gt;O(1)&lt;/math&gt; algorithm to find the largest number in &lt;math&gt;A&lt;/math&gt;.
:• Suppose you do not know what &lt;math&gt;k&lt;/math&gt; is. Give an &lt;math&gt;O(lg n)&lt;/math&gt; algorithm to find the largest number in &lt;math&gt;A&lt;/math&gt;. For partial credit, you may give an &lt;math&gt;O(n)&lt;/math&gt; algorithm.
[[5.1|Solution]]


:5.2. A sorted array of size n contains distinct integers between &lt;math&gt;1&lt;/math&gt; and &lt;math&gt;n + 1&lt;/math&gt; , with one element missing. Give an &lt;math&gt;O(log n)&lt;/math&gt; algorithm to find the missing integer, without using any extra space.


:[[5.3]] Consider the numerical Twenty Questions game. In this game, the first player thinks of a number in the range 1 to &lt;math&gt;n&lt;/math&gt;. The second player has to figure out this number by asking the fewest number of true/false questions. Assume that nobody cheats.
:(a) What is an optimal strategy if &lt;math&gt;n&lt;/math&gt; in known?
:(b) What is a good strategy if &lt;math&gt;n&lt;/math&gt; is not known?
[[5.3|Solution]]


:5.4. You are given a unimodal array of &lt;math&gt;n&lt;/math&gt; distinct elements, meaning that its entries are in increasing order up until its maximum element, after which its elements are in decreasing order. Give an algorithm to compute the maximum element of a unimodal array that runs in &lt;math&gt;O(log n)&lt;/math&gt; time.


:[[5.5]]. Suppose that you are given a sorted sequence of distinct integers &lt;math&gt;[a_1, a_2, . . . , a_n]&lt;/math&gt;. Give an &lt;math&gt;O(lg n)&lt;/math&gt; algorithm to determine whether there exists an index &lt;math&gt;i&lt;/math&gt; such that &lt;math&gt;a_i = i&lt;/math&gt;. For example, in [-10, -3, 3, 5, 7], &lt;math&gt;a_3 = 3&lt;/math&gt;. In [2, 3, 4, 5, 6, 7], there is no such &lt;math&gt;i&lt;/math&gt;.
[[5.5|Solution]]


:5.6. Suppose that you are given a sorted sequence of distinct integers &lt;math&gt;a = [a_1, a_2, . . . , a_n]&lt;/math&gt;, drawn from 1 to &lt;math&gt;m&lt;/math&gt; where &lt;math&gt;n &lt; m&lt;/math&gt;. Give an &lt;math&gt;O(lg n)&lt;/math&gt; algorithm to find an integer &lt;math&gt;\leq m&lt;/math&gt; that is not present in &lt;math&gt;a&lt;/math&gt;. For full credit, find the smallest such integer &lt;math&gt;x&lt;/math&gt; such that &lt;math&gt;1 \leq x \leq m&lt;/math&gt;.


:[[5.7]]. Let &lt;math&gt;M&lt;/math&gt; be an &lt;math&gt;n * m&lt;/math&gt; integer matrix in which the entries of each row are sorted in increasing order (from left to right) and the entries in each column are in increasing order (from top to bottom). Give an efficient algorithm to find the position of an integer &lt;math&gt;x&lt;/math&gt; in &lt;math&gt;M&lt;/math&gt;, or to determine that &lt;math&gt;x&lt;/math&gt; is not there. How many comparisons of &lt;math&gt;x&lt;/math&gt; with matrix entries does your algorithm use in worst case?
[[5.7|Solution]]

===Divide and Conquer Algorithms===

:5.8. Given two sorted arrays &lt;math&gt;A&lt;/math&gt; and &lt;math&gt;B&lt;/math&gt; of size &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;m&lt;/math&gt; respectively, find the median of the &lt;math&gt;n + m&lt;/math&gt; elements. The overall run time complexity should be &lt;math&gt;O(log(m + n))&lt;/math&gt;.


:[[5.9]]. The largest subrange problem, discussed in Section 5.6, takes an array &lt;math&gt;A&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; numbers, and asks for the index pair &lt;math&gt;i&lt;/math&gt; and &lt;math&gt;j&lt;/math&gt; that maximizes &lt;math&gt;S = \sum_{k=1}^j A[k]&lt;/math&gt;. Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for largest subrange.
[[5.9|Solution]]


:5.10. We are given &lt;math&gt;n&lt;/math&gt; wooden sticks, each of integer length, where the &lt;math&gt;i&lt;/math&gt;th piece has length &lt;math&gt;L[i]&lt;/math&gt;. We seek to cut them so that we end up with &lt;math&gt;k&lt;/math&gt; pieces of exactly the same length, in addition to other fragments. Furthermore, we want these &lt;math&gt;k&lt;/math&gt; pieces to be as large as possible.
:(a) Given four wood sticks, of lengths &lt;math&gt;L = {10, 6, 5, 3}&lt;/math&gt;, what are the largest sized pieces you can get for &lt;math&gt;k = 4&lt;/math&gt;? (Hint: the answer is not 3).
:(b) Give a correct and efficient algorithm that, for a given &lt;math&gt;L&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;, returns the maximum possible length of the &lt;math&gt;k&lt;/math&gt; equal pieces cut from the initial &lt;math&gt;n&lt;/math&gt; sticks.


:[[5.11]]. Extend the convolution-based string-matching algorithm described in the text to the case of pattern matching with wildcard characters “*”, which match any character. For example, “sh*t” should match both “shot” and “shut”.
[[5.11|Solution]]

===Recurrence Relations===

:5.12. In Section 5.3, it is asserted that any polynomial can be represented by a recurrence. Find a recurrence relation that represents the polynomial &lt;math&gt;a_n = n^2&lt;/math&gt;.


:[[5.13]]. Suppose you are choosing between the following three algorithms:
:• Algorithm &lt;math&gt;A&lt;/math&gt; solves problems by dividing them into five subproblems of half the size, recursively solving each subproblem, and then combining the solutions in linear time.
:• Algorithm &lt;math&gt;B&lt;/math&gt; solves problems of size &lt;math&gt;n&lt;/math&gt; by recursively solving two subproblems of size &lt;math&gt;n - 1&lt;/math&gt; and then combining the solutions in constant time.
:• Algorithm &lt;math&gt;C&lt;/math&gt; solves problems of size &lt;math&gt;n&lt;/math&gt; by dividing them into nine subproblems of size &lt;math&gt;n/3&lt;/math&gt;, recursively solving each subproblem, and then combining the solutions in &lt;math&gt;\Theta(n^2)&lt;/math&gt; time.
:What are the running times of each of these algorithms (in big O notation), and which would you choose?
[[5.13|Solution]]


:5.14. Solve the following recurrence relations and give a &lt;math&gt;\Theta&lt;/math&gt; bound for each of them:
:(a) &lt;math&gt;T(n) = 2T(n/3) + 1&lt;/math&gt;
:(b) &lt;math&gt;T(n) = 5T(n/4) + n&lt;/math&gt;
:(c) &lt;math&gt;T(n) = 7T(n/7) + n&lt;/math&gt;
:(d) &lt;math&gt;T(n) = 9T(n/3) + n^2&lt;/math&gt;


:[[5.15]]. Use the master theorem to solve the following recurrence relations:
:(a) &lt;math&gt;T(n) = 64T(n/4) + n^4&lt;/math&gt;
:(b) &lt;math&gt;T(n) = 64T(n/4) + n^3&lt;/math&gt;
:(c) &lt;math&gt;T(n) = 64T(n/4) + 128&lt;/math&gt;
[[5.15|Solution]]


:5.16. Give asymptotically tight upper (Big Oh) bounds for &lt;math&gt;T(n)&lt;/math&gt; in each of the following recurrences. Justify your solutions by naming the particular case of the master theorem, by iterating the recurrence, or by using the substitution method:
:(a) &lt;math&gt;T(n) = T(n - 2) + 1&lt;/math&gt;.
:(b) &lt;math&gt;T(n) = 2T(n/2) + n lg^2 n&lt;/math&gt;.
:(c) &lt;math&gt;T(n) = 9T(n/4) + n^2&lt;/math&gt;.


Back to [[Chapter List]]</text>
      <sha1>j80wcaqsafxoe1diekhlxvifmyrp7x9</sha1>
    </revision>
  </page>
  <page>
    <title>Chapter 6</title>
    <ns>0</ns>
    <id>9</id>
    <revision>
      <id>18</id>
      <timestamp>2020-08-23T19:35:03Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Problems   Back to [[Chapter List]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="35">Problems


Back to [[Chapter List]]</text>
      <sha1>95722ndl4ewzic1ak6z8g4auy0tqhc6</sha1>
    </revision>
    <revision>
      <id>114</id>
      <parentid>18</parentid>
      <timestamp>2020-09-07T18:20:35Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="236">=Hashing and Randomized Algorithms=

===Propability===

:[[6.1]]


:6.2


:[[6.3]]


:6.4


===Hashing===

:[[6.5]]


:6.6


:[[6.7]]


===Randomized Algorithms===

:6.8


:[[6.9]]


:6.10


:[[6.11]]


:6.12


Back to [[Chapter List]]</text>
      <sha1>si9xhe2g28s5uwkaapfufgr0a452pqg</sha1>
    </revision>
    <revision>
      <id>248</id>
      <parentid>114</parentid>
      <timestamp>2020-09-14T17:53:02Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Propability */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1835">=Hashing and Randomized Algorithms=

===Probability===

:[[6.1]]. You are given &lt;math&gt;n&lt;/math&gt; unbiased coins, and perform the following process to generate all heads. Toss all &lt;math&gt;n&lt;/math&gt; coins independently at random onto a table. Each round consists of picking up all the tails-up coins and tossing them onto the table again. You repeat until all coins are heads.
:(a) What is the expected number of rounds performed by the process?
:(b) What is the expected number of coin tosses performed by the process?
[[6.1|Solution]]


:6.2. Suppose we flip &lt;math&gt;n&lt;/math&gt; coins each of known bias, such that &lt;math&gt;p_i&lt;/math&gt; is the probability of the &lt;math&gt;i&lt;/math&gt;th coin being a head. Present an efficient algorithm to determine the exact probability of getting exactly &lt;math&gt;k&lt;/math&gt; heads given &lt;math&gt;p_1, . . . , p_n \in [0, 1]&lt;/math&gt;.


:[[6.3]]. An inversion of a permutation is a pair of elements that are out of order.
:(a) Show that a permutation of &lt;math&gt;n&lt;/math&gt; items has at most &lt;math&gt;n(n - 1)/2&lt;/math&gt; inversions. Which permutation(s) have exactly n(n - 1)/2 inversions?
:(b) Let P be a permutation and &lt;math&gt;P^r&lt;/math&gt; be the reversal of this permutation. Show that &lt;math&gt;P&lt;/math&gt; and &lt;math&gt;P^r&lt;/math&gt; have a total of exactly &lt;math&gt;n(n - 1)/2&lt;/math&gt; inversions.
:(c) Use the previous result to argue that the expected number of inversions in a random permutation is &lt;math&gt;n(n - 1)/4&lt;/math&gt;.
[[6.3|Solution]]


:6.4. A derangement is a permutation &lt;math&gt;p&lt;/math&gt; of &lt;math&gt;{1, . . . , n}&lt;/math&gt; such that no item is in its proper position, that is, &lt;math&gt;p_i \neq i&lt;/math&gt; for all &lt;math&gt;1 \leq i \leq n&lt;/math&gt;. What is the probability that a random permutation is a derangement?

===Hashing===

:[[6.5]]


:6.6


:[[6.7]]


===Randomized Algorithms===

:6.8


:[[6.9]]


:6.10


:[[6.11]]


:6.12


Back to [[Chapter List]]</text>
      <sha1>p3kfy2f4dli2pawtm8krwvbozuiuvj1</sha1>
    </revision>
    <revision>
      <id>249</id>
      <parentid>248</parentid>
      <timestamp>2020-09-14T17:57:20Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Hashing */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="3142">=Hashing and Randomized Algorithms=

===Probability===

:[[6.1]]. You are given &lt;math&gt;n&lt;/math&gt; unbiased coins, and perform the following process to generate all heads. Toss all &lt;math&gt;n&lt;/math&gt; coins independently at random onto a table. Each round consists of picking up all the tails-up coins and tossing them onto the table again. You repeat until all coins are heads.
:(a) What is the expected number of rounds performed by the process?
:(b) What is the expected number of coin tosses performed by the process?
[[6.1|Solution]]


:6.2. Suppose we flip &lt;math&gt;n&lt;/math&gt; coins each of known bias, such that &lt;math&gt;p_i&lt;/math&gt; is the probability of the &lt;math&gt;i&lt;/math&gt;th coin being a head. Present an efficient algorithm to determine the exact probability of getting exactly &lt;math&gt;k&lt;/math&gt; heads given &lt;math&gt;p_1, . . . , p_n \in [0, 1]&lt;/math&gt;.


:[[6.3]]. An inversion of a permutation is a pair of elements that are out of order.
:(a) Show that a permutation of &lt;math&gt;n&lt;/math&gt; items has at most &lt;math&gt;n(n - 1)/2&lt;/math&gt; inversions. Which permutation(s) have exactly n(n - 1)/2 inversions?
:(b) Let P be a permutation and &lt;math&gt;P^r&lt;/math&gt; be the reversal of this permutation. Show that &lt;math&gt;P&lt;/math&gt; and &lt;math&gt;P^r&lt;/math&gt; have a total of exactly &lt;math&gt;n(n - 1)/2&lt;/math&gt; inversions.
:(c) Use the previous result to argue that the expected number of inversions in a random permutation is &lt;math&gt;n(n - 1)/4&lt;/math&gt;.
[[6.3|Solution]]


:6.4. A derangement is a permutation &lt;math&gt;p&lt;/math&gt; of &lt;math&gt;{1, . . . , n}&lt;/math&gt; such that no item is in its proper position, that is, &lt;math&gt;p_i \neq i&lt;/math&gt; for all &lt;math&gt;1 \leq i \leq n&lt;/math&gt;. What is the probability that a random permutation is a derangement?

===Hashing===

:[[6.5]]. An all-Beatles radio station plays nothing but recordings by the Beatles, selecting the next song at random (uniformly with replacement). They get through about ten songs per hour. I listened for 90 minutes before hearing a repeated song. Estimate how many songs the Beatles recorded.
[[6.5|Solution]]


:6.6. Given strings &lt;math&gt;S&lt;/math&gt; and &lt;math&gt;T&lt;/math&gt; of length &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;m&lt;/math&gt; respectively, find the shortest window in &lt;math&gt;S&lt;/math&gt; that contains all the characters in &lt;math&gt;T&lt;/math&gt; in expected &lt;math&gt;O(n + m)&lt;/math&gt; time.


:[[6.7]]. Design and implement an efficient data structure to maintain a ''least recently used'' (LRU) cache of &lt;math&gt;n&lt;/math&gt; integer elements. A LRU cache will discard the least recently accessed element once the cache has reached its capacity, supporting the following operations:
:• ''get(k)''– Return the value associated with the key &lt;math&gt;k&lt;/math&gt; if it currently exists in the cache, otherwise return -1.
:• ''put(k,v)'' – Set the value associated with key &lt;math&gt;k&lt;/math&gt; to &lt;math&gt;v&lt;/math&gt;, or insert if &lt;math&gt;k&lt;/math&gt; is not already present. If there are already &lt;math&gt;n&lt;/math&gt; items in the queue, delete the least recently used item before inserting &lt;math&gt;(k, v)&lt;/math&gt;. Both operations should be done in &lt;math&gt;O(1)&lt;/math&gt; expected time.
[[6.7|Solution]]

===Randomized Algorithms===

:6.8


:[[6.9]]


:6.10


:[[6.11]]


:6.12


Back to [[Chapter List]]</text>
      <sha1>5kkcrp3xnx0lmn9f6rrkn0lhbs4blpj</sha1>
    </revision>
    <revision>
      <id>250</id>
      <parentid>249</parentid>
      <timestamp>2020-09-14T18:02:14Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Randomized Algorithms */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="4594">=Hashing and Randomized Algorithms=

===Probability===

:[[6.1]]. You are given &lt;math&gt;n&lt;/math&gt; unbiased coins, and perform the following process to generate all heads. Toss all &lt;math&gt;n&lt;/math&gt; coins independently at random onto a table. Each round consists of picking up all the tails-up coins and tossing them onto the table again. You repeat until all coins are heads.
:(a) What is the expected number of rounds performed by the process?
:(b) What is the expected number of coin tosses performed by the process?
[[6.1|Solution]]


:6.2. Suppose we flip &lt;math&gt;n&lt;/math&gt; coins each of known bias, such that &lt;math&gt;p_i&lt;/math&gt; is the probability of the &lt;math&gt;i&lt;/math&gt;th coin being a head. Present an efficient algorithm to determine the exact probability of getting exactly &lt;math&gt;k&lt;/math&gt; heads given &lt;math&gt;p_1, . . . , p_n \in [0, 1]&lt;/math&gt;.


:[[6.3]]. An inversion of a permutation is a pair of elements that are out of order.
:(a) Show that a permutation of &lt;math&gt;n&lt;/math&gt; items has at most &lt;math&gt;n(n - 1)/2&lt;/math&gt; inversions. Which permutation(s) have exactly n(n - 1)/2 inversions?
:(b) Let P be a permutation and &lt;math&gt;P^r&lt;/math&gt; be the reversal of this permutation. Show that &lt;math&gt;P&lt;/math&gt; and &lt;math&gt;P^r&lt;/math&gt; have a total of exactly &lt;math&gt;n(n - 1)/2&lt;/math&gt; inversions.
:(c) Use the previous result to argue that the expected number of inversions in a random permutation is &lt;math&gt;n(n - 1)/4&lt;/math&gt;.
[[6.3|Solution]]


:6.4. A derangement is a permutation &lt;math&gt;p&lt;/math&gt; of &lt;math&gt;{1, . . . , n}&lt;/math&gt; such that no item is in its proper position, that is, &lt;math&gt;p_i \neq i&lt;/math&gt; for all &lt;math&gt;1 \leq i \leq n&lt;/math&gt;. What is the probability that a random permutation is a derangement?

===Hashing===

:[[6.5]]. An all-Beatles radio station plays nothing but recordings by the Beatles, selecting the next song at random (uniformly with replacement). They get through about ten songs per hour. I listened for 90 minutes before hearing a repeated song. Estimate how many songs the Beatles recorded.
[[6.5|Solution]]


:6.6. Given strings &lt;math&gt;S&lt;/math&gt; and &lt;math&gt;T&lt;/math&gt; of length &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;m&lt;/math&gt; respectively, find the shortest window in &lt;math&gt;S&lt;/math&gt; that contains all the characters in &lt;math&gt;T&lt;/math&gt; in expected &lt;math&gt;O(n + m)&lt;/math&gt; time.


:[[6.7]]. Design and implement an efficient data structure to maintain a ''least recently used'' (LRU) cache of &lt;math&gt;n&lt;/math&gt; integer elements. A LRU cache will discard the least recently accessed element once the cache has reached its capacity, supporting the following operations:
:• ''get(k)''– Return the value associated with the key &lt;math&gt;k&lt;/math&gt; if it currently exists in the cache, otherwise return -1.
:• ''put(k,v)'' – Set the value associated with key &lt;math&gt;k&lt;/math&gt; to &lt;math&gt;v&lt;/math&gt;, or insert if &lt;math&gt;k&lt;/math&gt; is not already present. If there are already &lt;math&gt;n&lt;/math&gt; items in the queue, delete the least recently used item before inserting &lt;math&gt;(k, v)&lt;/math&gt;. Both operations should be done in &lt;math&gt;O(1)&lt;/math&gt; expected time.
[[6.7|Solution]]

===Randomized Algorithms===

:6.8. A pair of English words &lt;math&gt;(w_1, w_2)&lt;/math&gt; is called a ''rotodrome'' if one can be circularly shifted (rotated) to create the other word. For example, the words (windup, upwind) are a rotodrome pair, because we can rotate “windup” two positions to the right to get “upwind.”
:Give an efficient algorithm to find all rotodrome pairs among &lt;math&gt;n&lt;/math&gt; words of length &lt;math&gt;k&lt;/math&gt;, with a worst-case analysis. Also give a faster expected-time algorithm based on hashing.


:[[6.9]]. Given an array &lt;math&gt;w&lt;/math&gt; of positive integers, where &lt;math&gt;w[i]&lt;/math&gt; describes the weight of index &lt;math&gt;i&lt;/math&gt;, propose an algorithm that randomly picks an index in proportion to its weight.
[[6.9|Solution]]


:6.10. You are given a function ''rand7'', which generates a uniform random integer in the range 1 to 7. Use it to produce a function ''rand10'', which generates a uniform random integer in the range 1 to 10.


:[[6.11]]. Let &lt;math&gt;0 &lt; \alpha &lt; 1/2&lt;/math&gt; be some constant, independent of the input array length &lt;math&gt;n&lt;/math&gt;. What is the probability that, with a randomly chosen pivot element, the partition subroutine from quicksort produces a split in which the size of both the resulting subproblems is at least &lt;math&gt;\alpha&lt;/math&gt; times the size of the original array?
[[6.11|Solution]]


:6.12. Show that for any given load &lt;math&gt;m/n&lt;/math&gt;, the error probability of a Bloom filter is minimized when the number of hash functions is &lt;math&gt;k = exp(-1)/(m/n)&lt;/math&gt;.


Back to [[Chapter List]]</text>
      <sha1>deba9yduoziigxfiznwcbpwzxg208zg</sha1>
    </revision>
    <revision>
      <id>451</id>
      <parentid>250</parentid>
      <timestamp>2020-10-01T18:08:44Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <minor/>
      <comment>Protected "[[Chapter 6]]" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="4594">=Hashing and Randomized Algorithms=

===Probability===

:[[6.1]]. You are given &lt;math&gt;n&lt;/math&gt; unbiased coins, and perform the following process to generate all heads. Toss all &lt;math&gt;n&lt;/math&gt; coins independently at random onto a table. Each round consists of picking up all the tails-up coins and tossing them onto the table again. You repeat until all coins are heads.
:(a) What is the expected number of rounds performed by the process?
:(b) What is the expected number of coin tosses performed by the process?
[[6.1|Solution]]


:6.2. Suppose we flip &lt;math&gt;n&lt;/math&gt; coins each of known bias, such that &lt;math&gt;p_i&lt;/math&gt; is the probability of the &lt;math&gt;i&lt;/math&gt;th coin being a head. Present an efficient algorithm to determine the exact probability of getting exactly &lt;math&gt;k&lt;/math&gt; heads given &lt;math&gt;p_1, . . . , p_n \in [0, 1]&lt;/math&gt;.


:[[6.3]]. An inversion of a permutation is a pair of elements that are out of order.
:(a) Show that a permutation of &lt;math&gt;n&lt;/math&gt; items has at most &lt;math&gt;n(n - 1)/2&lt;/math&gt; inversions. Which permutation(s) have exactly n(n - 1)/2 inversions?
:(b) Let P be a permutation and &lt;math&gt;P^r&lt;/math&gt; be the reversal of this permutation. Show that &lt;math&gt;P&lt;/math&gt; and &lt;math&gt;P^r&lt;/math&gt; have a total of exactly &lt;math&gt;n(n - 1)/2&lt;/math&gt; inversions.
:(c) Use the previous result to argue that the expected number of inversions in a random permutation is &lt;math&gt;n(n - 1)/4&lt;/math&gt;.
[[6.3|Solution]]


:6.4. A derangement is a permutation &lt;math&gt;p&lt;/math&gt; of &lt;math&gt;{1, . . . , n}&lt;/math&gt; such that no item is in its proper position, that is, &lt;math&gt;p_i \neq i&lt;/math&gt; for all &lt;math&gt;1 \leq i \leq n&lt;/math&gt;. What is the probability that a random permutation is a derangement?

===Hashing===

:[[6.5]]. An all-Beatles radio station plays nothing but recordings by the Beatles, selecting the next song at random (uniformly with replacement). They get through about ten songs per hour. I listened for 90 minutes before hearing a repeated song. Estimate how many songs the Beatles recorded.
[[6.5|Solution]]


:6.6. Given strings &lt;math&gt;S&lt;/math&gt; and &lt;math&gt;T&lt;/math&gt; of length &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;m&lt;/math&gt; respectively, find the shortest window in &lt;math&gt;S&lt;/math&gt; that contains all the characters in &lt;math&gt;T&lt;/math&gt; in expected &lt;math&gt;O(n + m)&lt;/math&gt; time.


:[[6.7]]. Design and implement an efficient data structure to maintain a ''least recently used'' (LRU) cache of &lt;math&gt;n&lt;/math&gt; integer elements. A LRU cache will discard the least recently accessed element once the cache has reached its capacity, supporting the following operations:
:• ''get(k)''– Return the value associated with the key &lt;math&gt;k&lt;/math&gt; if it currently exists in the cache, otherwise return -1.
:• ''put(k,v)'' – Set the value associated with key &lt;math&gt;k&lt;/math&gt; to &lt;math&gt;v&lt;/math&gt;, or insert if &lt;math&gt;k&lt;/math&gt; is not already present. If there are already &lt;math&gt;n&lt;/math&gt; items in the queue, delete the least recently used item before inserting &lt;math&gt;(k, v)&lt;/math&gt;. Both operations should be done in &lt;math&gt;O(1)&lt;/math&gt; expected time.
[[6.7|Solution]]

===Randomized Algorithms===

:6.8. A pair of English words &lt;math&gt;(w_1, w_2)&lt;/math&gt; is called a ''rotodrome'' if one can be circularly shifted (rotated) to create the other word. For example, the words (windup, upwind) are a rotodrome pair, because we can rotate “windup” two positions to the right to get “upwind.”
:Give an efficient algorithm to find all rotodrome pairs among &lt;math&gt;n&lt;/math&gt; words of length &lt;math&gt;k&lt;/math&gt;, with a worst-case analysis. Also give a faster expected-time algorithm based on hashing.


:[[6.9]]. Given an array &lt;math&gt;w&lt;/math&gt; of positive integers, where &lt;math&gt;w[i]&lt;/math&gt; describes the weight of index &lt;math&gt;i&lt;/math&gt;, propose an algorithm that randomly picks an index in proportion to its weight.
[[6.9|Solution]]


:6.10. You are given a function ''rand7'', which generates a uniform random integer in the range 1 to 7. Use it to produce a function ''rand10'', which generates a uniform random integer in the range 1 to 10.


:[[6.11]]. Let &lt;math&gt;0 &lt; \alpha &lt; 1/2&lt;/math&gt; be some constant, independent of the input array length &lt;math&gt;n&lt;/math&gt;. What is the probability that, with a randomly chosen pivot element, the partition subroutine from quicksort produces a split in which the size of both the resulting subproblems is at least &lt;math&gt;\alpha&lt;/math&gt; times the size of the original array?
[[6.11|Solution]]


:6.12. Show that for any given load &lt;math&gt;m/n&lt;/math&gt;, the error probability of a Bloom filter is minimized when the number of hash functions is &lt;math&gt;k = exp(-1)/(m/n)&lt;/math&gt;.


Back to [[Chapter List]]</text>
      <sha1>deba9yduoziigxfiznwcbpwzxg208zg</sha1>
    </revision>
  </page>
  <page>
    <title>Chapter 7</title>
    <ns>0</ns>
    <id>10</id>
    <revision>
      <id>19</id>
      <timestamp>2020-08-23T19:35:13Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Problems   Back to [[Chapter List]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="35">Problems


Back to [[Chapter List]]</text>
      <sha1>95722ndl4ewzic1ak6z8g4auy0tqhc6</sha1>
    </revision>
    <revision>
      <id>115</id>
      <parentid>19</parentid>
      <timestamp>2020-09-07T18:29:39Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="637">=Graph Traversal=

===Simulating Graph Algorithms===

:[[7.1]]


:7.2


===Traversal==

:[[7.3]]


:7.4


:[[7.5]]


:7.6


:[[7.7]]


:7.8


:[[7.9]]


:7.10


:[[7.11]]


:7.12


===Applications

:[[7.13]]


:7.14


:[[7.15]]


===Algorithm Design===

:7.16


:[[7.17]]


:7.18


:[[7.19]]


:7.20


:[[7.21]]]


:7.22


:[[7.23]]


:7.24


:[[7.25]]


:7.26


===Directed Graphs===

:[[7.27]]


:7.28


:[[7.29]]


:7.30


:[[7.31]]


:7.32


:[[7.33]]


:7.34


:[[7.35]]


:7.36


:[[7.37]]


===Articulation Vertices===

:7.38


:[[7.39]]


:7.40


:[[7.41]]


===Interview Problems===

:7.42


:[[7.43]]


Back to [[Chapter List]]</text>
      <sha1>fghrtjrzaiq19nt64ra2kerfpumtc5m</sha1>
    </revision>
    <revision>
      <id>116</id>
      <parentid>115</parentid>
      <timestamp>2020-09-07T18:30:02Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* =Traversal */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="638">=Graph Traversal=

===Simulating Graph Algorithms===

:[[7.1]]


:7.2


===Traversal===

:[[7.3]]


:7.4


:[[7.5]]


:7.6


:[[7.7]]


:7.8


:[[7.9]]


:7.10


:[[7.11]]


:7.12


===Applications

:[[7.13]]


:7.14


:[[7.15]]


===Algorithm Design===

:7.16


:[[7.17]]


:7.18


:[[7.19]]


:7.20


:[[7.21]]]


:7.22


:[[7.23]]


:7.24


:[[7.25]]


:7.26


===Directed Graphs===

:[[7.27]]


:7.28


:[[7.29]]


:7.30


:[[7.31]]


:7.32


:[[7.33]]


:7.34


:[[7.35]]


:7.36


:[[7.37]]


===Articulation Vertices===

:7.38


:[[7.39]]


:7.40


:[[7.41]]


===Interview Problems===

:7.42


:[[7.43]]


Back to [[Chapter List]]</text>
      <sha1>c768ou4c08iwi2rq7smql6c1n8csdzn</sha1>
    </revision>
    <revision>
      <id>117</id>
      <parentid>116</parentid>
      <timestamp>2020-09-07T18:30:17Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Traversal */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="640">=Graph Traversal=

===Simulating Graph Algorithms===

:[[7.1]]


:7.2


===Traversal===

:[[7.3]]


:7.4


:[[7.5]]


:7.6


:[[7.7]]


:7.8


:[[7.9]]


:7.10


:[[7.11]]


:7.12


===Applications===

:[[7.13]]


:7.14


:[[7.15]]

===Algorithm Design===

:7.16


:[[7.17]]


:7.18


:[[7.19]]


:7.20


:[[7.21]]]


:7.22


:[[7.23]]


:7.24


:[[7.25]]


:7.26


===Directed Graphs===

:[[7.27]]


:7.28


:[[7.29]]


:7.30


:[[7.31]]


:7.32


:[[7.33]]


:7.34


:[[7.35]]


:7.36


:[[7.37]]


===Articulation Vertices===

:7.38


:[[7.39]]


:7.40


:[[7.41]]


===Interview Problems===

:7.42


:[[7.43]]


Back to [[Chapter List]]</text>
      <sha1>skwy6htvyct6yyfrb9i2zaq7bmcl13b</sha1>
    </revision>
    <revision>
      <id>239</id>
      <parentid>117</parentid>
      <timestamp>2020-09-14T16:13:10Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Simulating Graph Algorithms */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1311">=Graph Traversal=

===Simulating Graph Algorithms===

:[[7.1]]. For the following graphs &lt;math&gt;G_1&lt;/math&gt; (left) and &lt;math&gt;G_2&lt;/math&gt; (right):
&lt;br&gt;(see book for figure)
&lt;br&gt;(see book for figure)
:(a)Report the order of the vertices encountered on a breadth-first search starting from vertex &lt;math&gt;A&lt;/math&gt;. Break all ties by picking the vertices in alphabetical order (i.e., &lt;math&gt;A&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt;).
(b)Report the order of the vertices encountered on a depth-first search starting from vertex &lt;math&gt;A&lt;/math&gt;. Break all ties by picking the vertices in alphabetical order (i.e., &lt;math&gt;A&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt;).
[[7.1|Solution]]


:7.2. Do a topological sort of the following graph &lt;math&gt;G&lt;/math&gt;:
&lt;br&gt;(see book for figure)

===Traversal===

:[[7.3]]


:7.4


:[[7.5]]


:7.6


:[[7.7]]


:7.8


:[[7.9]]


:7.10


:[[7.11]]


:7.12


===Applications===

:[[7.13]]


:7.14


:[[7.15]]

===Algorithm Design===

:7.16


:[[7.17]]


:7.18


:[[7.19]]


:7.20


:[[7.21]]]


:7.22


:[[7.23]]


:7.24


:[[7.25]]


:7.26


===Directed Graphs===

:[[7.27]]


:7.28


:[[7.29]]


:7.30


:[[7.31]]


:7.32


:[[7.33]]


:7.34


:[[7.35]]


:7.36


:[[7.37]]


===Articulation Vertices===

:7.38


:[[7.39]]


:7.40


:[[7.41]]


===Interview Problems===

:7.42


:[[7.43]]


Back to [[Chapter List]]</text>
      <sha1>g6vyju7lzj7idto6r19662oet42tvuz</sha1>
    </revision>
    <revision>
      <id>240</id>
      <parentid>239</parentid>
      <timestamp>2020-09-14T16:13:43Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Simulating Graph Algorithms */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1282">=Graph Traversal=

===Simulating Graph Algorithms===

:[[7.1]]. For the following graphs &lt;math&gt;G_1&lt;/math&gt; (left) and &lt;math&gt;G_2&lt;/math&gt; (right):
:(see book for figures)

:(a)Report the order of the vertices encountered on a breadth-first search starting from vertex &lt;math&gt;A&lt;/math&gt;. Break all ties by picking the vertices in alphabetical order (i.e., &lt;math&gt;A&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt;).
:(b)Report the order of the vertices encountered on a depth-first search starting from vertex &lt;math&gt;A&lt;/math&gt;. Break all ties by picking the vertices in alphabetical order (i.e., &lt;math&gt;A&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt;).
[[7.1|Solution]]


:7.2. Do a topological sort of the following graph &lt;math&gt;G&lt;/math&gt;:
:(see book for figure)

===Traversal===

:[[7.3]]


:7.4


:[[7.5]]


:7.6


:[[7.7]]


:7.8


:[[7.9]]


:7.10


:[[7.11]]


:7.12


===Applications===

:[[7.13]]


:7.14


:[[7.15]]

===Algorithm Design===

:7.16


:[[7.17]]


:7.18


:[[7.19]]


:7.20


:[[7.21]]]


:7.22


:[[7.23]]


:7.24


:[[7.25]]


:7.26


===Directed Graphs===

:[[7.27]]


:7.28


:[[7.29]]


:7.30


:[[7.31]]


:7.32


:[[7.33]]


:7.34


:[[7.35]]


:7.36


:[[7.37]]


===Articulation Vertices===

:7.38


:[[7.39]]


:7.40


:[[7.41]]


===Interview Problems===

:7.42


:[[7.43]]


Back to [[Chapter List]]</text>
      <sha1>g1zqy6vggs1b13buc38ocx58xmbt0l1</sha1>
    </revision>
    <revision>
      <id>241</id>
      <parentid>240</parentid>
      <timestamp>2020-09-14T16:25:02Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Traversal */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="5379">=Graph Traversal=

===Simulating Graph Algorithms===

:[[7.1]]. For the following graphs &lt;math&gt;G_1&lt;/math&gt; (left) and &lt;math&gt;G_2&lt;/math&gt; (right):
:(see book for figures)

:(a)Report the order of the vertices encountered on a breadth-first search starting from vertex &lt;math&gt;A&lt;/math&gt;. Break all ties by picking the vertices in alphabetical order (i.e., &lt;math&gt;A&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt;).
:(b)Report the order of the vertices encountered on a depth-first search starting from vertex &lt;math&gt;A&lt;/math&gt;. Break all ties by picking the vertices in alphabetical order (i.e., &lt;math&gt;A&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt;).
[[7.1|Solution]]


:7.2. Do a topological sort of the following graph &lt;math&gt;G&lt;/math&gt;:
:(see book for figure)

===Traversal===

:[[7.3]]. Prove that there is a unique path between any pair of vertices in a tree.
[[7.3|Solution]]


:7.4. Prove that in a breadth-first search on a undirected graph &lt;math&gt;G&lt;/math&gt;, every edge is either a tree edge or a cross edge, where &lt;math&gt;x&lt;/math&gt; is neither an ancestor nor descendant of &lt;math&gt;y&lt;/math&gt; in cross edge &lt;math&gt;(x, y)&lt;/math&gt;.


:[[7.5]]. Give a linear algorithm to compute the chromatic number of graphs where each vertex has degree at most 2. Any bipartite graph has a chromatic number of 2. Must such graphs be bipartite?
[[7.5|Solution]]


:7.6. You are given a connected, undirected graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges. Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm to identify an edge you can remove from &lt;math&gt;G&lt;/math&gt; while still leaving &lt;math&gt;G&lt;/math&gt; connected, if one exists. Can you reduce the running time to &lt;math&gt;O(n)&lt;/math&gt;?


:[[7.7]]. In breadth-first and depth-first search, an undiscovered node is marked ''discovered'' when it is first encountered, and marked ''processed'' when it has been completely searched. At any given moment, several nodes might be simultaneously in the ''discovered'' state.
:(a) Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that &lt;math&gt;\Theta(n)&lt;/math&gt; nodes are simultaneously in the ''discovered'' state during a ''breadth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.
:(b) Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that &lt;math&gt;\Theta(n)&lt;/math&gt; nodes are simultaneously in the ''discovered'' state during a ''depth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.
:(c)  Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that at some point &lt;math&gt;\Theta(n)&lt;/math&gt; nodes remain ''undiscovered'', while &lt;math&gt;\Theta(n)&lt;/math&gt; nodes have been ''processed'' during a ''depth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.(Note, there may also be ''discovered'' nodes.)
[[7.7|Solution]]


:7.8. Given pre-order and in-order traversals of a binary tree (discussed in Section 3.4.1), is it possible to reconstruct the tree? If so, sketch an algorithm to do it. If not, give a counterexample. Repeat the problem if you are given the pre-order and post-order traversals.


:[[7.9]]. Present correct and efficient algorithms to convert an undirected graph &lt;math&gt;G&lt;/math&gt; between the following graph data structures. You must give the time complexity of each algorithm, assuming &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges.
:(a)Convert from an adjacency matrix to adjacency lists.
:(b)Convert from an adjacency list to an incidence matrix. An incidence matrix &lt;math&gt;M&lt;/math&gt; has a row for each vertex and a column for each edge, such that &lt;math&gt;M[i,j]=1&lt;/math&gt; if vertex &lt;math&gt;i&lt;/math&gt; is part of edge &lt;math&gt;j&lt;/math&gt;, otherwise &lt;math&gt;M[i,j] = 0&lt;/math&gt;.
:(c)Convert from an incidence matrix to adjacency lists.
[[7.9|Solution]]


:7.10. Suppose an arithmetic expression is given as a tree. Each leaf is an integer and each internal node is one of the standard arithmetical operations &lt;math&gt;(+, -, *, /)&lt;/math&gt;. For example, the expression &lt;math&gt;2+3*4+(3*4)/5&lt;/math&gt; is represented by the tree in Figure 7.17(a). Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for evaluating such an expression, where there are &lt;math&gt;n&lt;/math&gt; nodes in the tree.


:[[7.11]]. Suppose an arithmetic expression is given as a DAG (directed acyclic graph) with common subexpressions removed. Each leaf is an integer and each internal node is one of the standard arithmetical operations &lt;math&gt;(+,-,*,/)&lt;/math&gt;. For example, the expression &lt;math&gt;2+3*4+(3*4)/5&lt;/math&gt; is represented by the DAG in Figure (see book)(b). Give an &lt;math&gt;O(n+m)&lt;/math&gt; algorithm for evaluating such a DAG, where there are &lt;math&gt;n&lt;/math&gt; nodes and &lt;math&gt;m&lt;/math&gt; edges in the DAG. Hint: modify an algorithm for the tree case to achieve the desired efficiency.
[[7.11|Solution]]


:7.12. The war story of Section 7.4 (page 210) describes an algorithm for constructing the dual graph of the triangulation efficiently, although it does not guarantee linear time. Give a worst-case linear algorithm for the problem.

===Applications===

:[[7.13]]


:7.14


:[[7.15]]

===Algorithm Design===

:7.16


:[[7.17]]


:7.18


:[[7.19]]


:7.20


:[[7.21]]]


:7.22


:[[7.23]]


:7.24


:[[7.25]]


:7.26


===Directed Graphs===

:[[7.27]]


:7.28


:[[7.29]]


:7.30


:[[7.31]]


:7.32


:[[7.33]]


:7.34


:[[7.35]]


:7.36


:[[7.37]]


===Articulation Vertices===

:7.38


:[[7.39]]


:7.40


:[[7.41]]


===Interview Problems===

:7.42


:[[7.43]]


Back to [[Chapter List]]</text>
      <sha1>kgf0r90hgegr2bizutsrum58frobo7m</sha1>
    </revision>
    <revision>
      <id>242</id>
      <parentid>241</parentid>
      <timestamp>2020-09-14T16:31:00Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Applications */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="7182">=Graph Traversal=

===Simulating Graph Algorithms===

:[[7.1]]. For the following graphs &lt;math&gt;G_1&lt;/math&gt; (left) and &lt;math&gt;G_2&lt;/math&gt; (right):
:(see book for figures)

:(a)Report the order of the vertices encountered on a breadth-first search starting from vertex &lt;math&gt;A&lt;/math&gt;. Break all ties by picking the vertices in alphabetical order (i.e., &lt;math&gt;A&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt;).
:(b)Report the order of the vertices encountered on a depth-first search starting from vertex &lt;math&gt;A&lt;/math&gt;. Break all ties by picking the vertices in alphabetical order (i.e., &lt;math&gt;A&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt;).
[[7.1|Solution]]


:7.2. Do a topological sort of the following graph &lt;math&gt;G&lt;/math&gt;:
:(see book for figure)

===Traversal===

:[[7.3]]. Prove that there is a unique path between any pair of vertices in a tree.
[[7.3|Solution]]


:7.4. Prove that in a breadth-first search on a undirected graph &lt;math&gt;G&lt;/math&gt;, every edge is either a tree edge or a cross edge, where &lt;math&gt;x&lt;/math&gt; is neither an ancestor nor descendant of &lt;math&gt;y&lt;/math&gt; in cross edge &lt;math&gt;(x, y)&lt;/math&gt;.


:[[7.5]]. Give a linear algorithm to compute the chromatic number of graphs where each vertex has degree at most 2. Any bipartite graph has a chromatic number of 2. Must such graphs be bipartite?
[[7.5|Solution]]


:7.6. You are given a connected, undirected graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges. Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm to identify an edge you can remove from &lt;math&gt;G&lt;/math&gt; while still leaving &lt;math&gt;G&lt;/math&gt; connected, if one exists. Can you reduce the running time to &lt;math&gt;O(n)&lt;/math&gt;?


:[[7.7]]. In breadth-first and depth-first search, an undiscovered node is marked ''discovered'' when it is first encountered, and marked ''processed'' when it has been completely searched. At any given moment, several nodes might be simultaneously in the ''discovered'' state.
:(a) Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that &lt;math&gt;\Theta(n)&lt;/math&gt; nodes are simultaneously in the ''discovered'' state during a ''breadth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.
:(b) Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that &lt;math&gt;\Theta(n)&lt;/math&gt; nodes are simultaneously in the ''discovered'' state during a ''depth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.
:(c)  Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that at some point &lt;math&gt;\Theta(n)&lt;/math&gt; nodes remain ''undiscovered'', while &lt;math&gt;\Theta(n)&lt;/math&gt; nodes have been ''processed'' during a ''depth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.(Note, there may also be ''discovered'' nodes.)
[[7.7|Solution]]


:7.8. Given pre-order and in-order traversals of a binary tree (discussed in Section 3.4.1), is it possible to reconstruct the tree? If so, sketch an algorithm to do it. If not, give a counterexample. Repeat the problem if you are given the pre-order and post-order traversals.


:[[7.9]]. Present correct and efficient algorithms to convert an undirected graph &lt;math&gt;G&lt;/math&gt; between the following graph data structures. You must give the time complexity of each algorithm, assuming &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges.
:(a)Convert from an adjacency matrix to adjacency lists.
:(b)Convert from an adjacency list to an incidence matrix. An incidence matrix &lt;math&gt;M&lt;/math&gt; has a row for each vertex and a column for each edge, such that &lt;math&gt;M[i,j]=1&lt;/math&gt; if vertex &lt;math&gt;i&lt;/math&gt; is part of edge &lt;math&gt;j&lt;/math&gt;, otherwise &lt;math&gt;M[i,j] = 0&lt;/math&gt;.
:(c)Convert from an incidence matrix to adjacency lists.
[[7.9|Solution]]


:7.10. Suppose an arithmetic expression is given as a tree. Each leaf is an integer and each internal node is one of the standard arithmetical operations &lt;math&gt;(+, -, *, /)&lt;/math&gt;. For example, the expression &lt;math&gt;2+3*4+(3*4)/5&lt;/math&gt; is represented by the tree in Figure 7.17(a). Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for evaluating such an expression, where there are &lt;math&gt;n&lt;/math&gt; nodes in the tree.


:[[7.11]]. Suppose an arithmetic expression is given as a DAG (directed acyclic graph) with common subexpressions removed. Each leaf is an integer and each internal node is one of the standard arithmetical operations &lt;math&gt;(+,-,*,/)&lt;/math&gt;. For example, the expression &lt;math&gt;2+3*4+(3*4)/5&lt;/math&gt; is represented by the DAG in Figure (see book)(b). Give an &lt;math&gt;O(n+m)&lt;/math&gt; algorithm for evaluating such a DAG, where there are &lt;math&gt;n&lt;/math&gt; nodes and &lt;math&gt;m&lt;/math&gt; edges in the DAG. Hint: modify an algorithm for the tree case to achieve the desired efficiency.
[[7.11|Solution]]


:7.12. The war story of Section 7.4 (page 210) describes an algorithm for constructing the dual graph of the triangulation efficiently, although it does not guarantee linear time. Give a worst-case linear algorithm for the problem.

===Applications===

:[[7.13]]. The Chutes and Ladders game has a board with n cells where you seek to travel from cell 1 to cell &lt;math&gt;n&lt;/math&gt;. To move, a player throws a six-sided dice to determine how many cells forward they move. This board also contains chutes and ladders that connect certain pairs of cells. A player who lands on the mouth of a chute immediately falls back down to the cell at the other end. A player who lands on the base of a ladder immediately travels up to the cell at the top of the ladder. Suppose you have rigged the dice to give you full control of the number for each roll. Give an efficient algorithm to find the minimum number of dice throws to win.
[[7.13|Solution]]


:7.14. Plum blossom poles are a Kung Fu training technique, consisting of &lt;math&gt;n&lt;/math&gt; large posts partially sunk into the ground, with each pole &lt;math&gt;p_i&lt;/math&gt; at position &lt;math&gt;(x_i, y_i)&lt;/math&gt;. Students practice martial arts techniques by stepping from the top of one pole to the top of another pole. In order to keep balance, each step must be more than &lt;math&gt;d&lt;/math&gt; meters but less than &lt;math&gt;2d&lt;/math&gt; meters. Give an efficient algorithm to find a safe path from pole &lt;math&gt;p_s&lt;/math&gt; to &lt;math&gt;p_t&lt;/math&gt; if it exists.


:[[7.15]]. You are planning the seating arrangement for a wedding given a list of guests, &lt;math&gt;V&lt;/math&gt;. For each guest &lt;math&gt;g&lt;/math&gt; you have a list of all other guests who are on bad terms with them. Feelings are reciprocal: if &lt;math&gt;h&lt;/math&gt; is on bad terms with &lt;math&gt;g&lt;/math&gt;, then &lt;math&gt;g&lt;/math&gt; is on bad terms with &lt;math&gt;h&lt;/math&gt;. Your goal is to arrange the seating such that no pair of guests sitting at the same table are on bad terms with each other. There will be only two tables at the wedding. Give an efficient algorithm to find an acceptable seating arrangement if one exists.
[[7.15|Solution]]

===Algorithm Design===

:7.16


:[[7.17]]


:7.18


:[[7.19]]


:7.20


:[[7.21]]]


:7.22


:[[7.23]]


:7.24


:[[7.25]]


:7.26


===Directed Graphs===

:[[7.27]]


:7.28


:[[7.29]]


:7.30


:[[7.31]]


:7.32


:[[7.33]]


:7.34


:[[7.35]]


:7.36


:[[7.37]]


===Articulation Vertices===

:7.38


:[[7.39]]


:7.40


:[[7.41]]


===Interview Problems===

:7.42


:[[7.43]]


Back to [[Chapter List]]</text>
      <sha1>8era8fiettu9z7teil490yzblhapmlk</sha1>
    </revision>
    <revision>
      <id>243</id>
      <parentid>242</parentid>
      <timestamp>2020-09-14T17:13:32Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Algorithm Design */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="12785">=Graph Traversal=

===Simulating Graph Algorithms===

:[[7.1]]. For the following graphs &lt;math&gt;G_1&lt;/math&gt; (left) and &lt;math&gt;G_2&lt;/math&gt; (right):
:(see book for figures)

:(a)Report the order of the vertices encountered on a breadth-first search starting from vertex &lt;math&gt;A&lt;/math&gt;. Break all ties by picking the vertices in alphabetical order (i.e., &lt;math&gt;A&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt;).
:(b)Report the order of the vertices encountered on a depth-first search starting from vertex &lt;math&gt;A&lt;/math&gt;. Break all ties by picking the vertices in alphabetical order (i.e., &lt;math&gt;A&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt;).
[[7.1|Solution]]


:7.2. Do a topological sort of the following graph &lt;math&gt;G&lt;/math&gt;:
:(see book for figure)

===Traversal===

:[[7.3]]. Prove that there is a unique path between any pair of vertices in a tree.
[[7.3|Solution]]


:7.4. Prove that in a breadth-first search on a undirected graph &lt;math&gt;G&lt;/math&gt;, every edge is either a tree edge or a cross edge, where &lt;math&gt;x&lt;/math&gt; is neither an ancestor nor descendant of &lt;math&gt;y&lt;/math&gt; in cross edge &lt;math&gt;(x, y)&lt;/math&gt;.


:[[7.5]]. Give a linear algorithm to compute the chromatic number of graphs where each vertex has degree at most 2. Any bipartite graph has a chromatic number of 2. Must such graphs be bipartite?
[[7.5|Solution]]


:7.6. You are given a connected, undirected graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges. Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm to identify an edge you can remove from &lt;math&gt;G&lt;/math&gt; while still leaving &lt;math&gt;G&lt;/math&gt; connected, if one exists. Can you reduce the running time to &lt;math&gt;O(n)&lt;/math&gt;?


:[[7.7]]. In breadth-first and depth-first search, an undiscovered node is marked ''discovered'' when it is first encountered, and marked ''processed'' when it has been completely searched. At any given moment, several nodes might be simultaneously in the ''discovered'' state.
:(a) Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that &lt;math&gt;\Theta(n)&lt;/math&gt; nodes are simultaneously in the ''discovered'' state during a ''breadth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.
:(b) Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that &lt;math&gt;\Theta(n)&lt;/math&gt; nodes are simultaneously in the ''discovered'' state during a ''depth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.
:(c)  Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that at some point &lt;math&gt;\Theta(n)&lt;/math&gt; nodes remain ''undiscovered'', while &lt;math&gt;\Theta(n)&lt;/math&gt; nodes have been ''processed'' during a ''depth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.(Note, there may also be ''discovered'' nodes.)
[[7.7|Solution]]


:7.8. Given pre-order and in-order traversals of a binary tree (discussed in Section 3.4.1), is it possible to reconstruct the tree? If so, sketch an algorithm to do it. If not, give a counterexample. Repeat the problem if you are given the pre-order and post-order traversals.


:[[7.9]]. Present correct and efficient algorithms to convert an undirected graph &lt;math&gt;G&lt;/math&gt; between the following graph data structures. You must give the time complexity of each algorithm, assuming &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges.
:(a)Convert from an adjacency matrix to adjacency lists.
:(b)Convert from an adjacency list to an incidence matrix. An incidence matrix &lt;math&gt;M&lt;/math&gt; has a row for each vertex and a column for each edge, such that &lt;math&gt;M[i,j]=1&lt;/math&gt; if vertex &lt;math&gt;i&lt;/math&gt; is part of edge &lt;math&gt;j&lt;/math&gt;, otherwise &lt;math&gt;M[i,j] = 0&lt;/math&gt;.
:(c)Convert from an incidence matrix to adjacency lists.
[[7.9|Solution]]


:7.10. Suppose an arithmetic expression is given as a tree. Each leaf is an integer and each internal node is one of the standard arithmetical operations &lt;math&gt;(+, -, *, /)&lt;/math&gt;. For example, the expression &lt;math&gt;2+3*4+(3*4)/5&lt;/math&gt; is represented by the tree in Figure 7.17(a). Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for evaluating such an expression, where there are &lt;math&gt;n&lt;/math&gt; nodes in the tree.


:[[7.11]]. Suppose an arithmetic expression is given as a DAG (directed acyclic graph) with common subexpressions removed. Each leaf is an integer and each internal node is one of the standard arithmetical operations &lt;math&gt;(+,-,*,/)&lt;/math&gt;. For example, the expression &lt;math&gt;2+3*4+(3*4)/5&lt;/math&gt; is represented by the DAG in Figure (see book)(b). Give an &lt;math&gt;O(n+m)&lt;/math&gt; algorithm for evaluating such a DAG, where there are &lt;math&gt;n&lt;/math&gt; nodes and &lt;math&gt;m&lt;/math&gt; edges in the DAG. Hint: modify an algorithm for the tree case to achieve the desired efficiency.
[[7.11|Solution]]


:7.12. The war story of Section 7.4 (page 210) describes an algorithm for constructing the dual graph of the triangulation efficiently, although it does not guarantee linear time. Give a worst-case linear algorithm for the problem.

===Applications===

:[[7.13]]. The Chutes and Ladders game has a board with n cells where you seek to travel from cell 1 to cell &lt;math&gt;n&lt;/math&gt;. To move, a player throws a six-sided dice to determine how many cells forward they move. This board also contains chutes and ladders that connect certain pairs of cells. A player who lands on the mouth of a chute immediately falls back down to the cell at the other end. A player who lands on the base of a ladder immediately travels up to the cell at the top of the ladder. Suppose you have rigged the dice to give you full control of the number for each roll. Give an efficient algorithm to find the minimum number of dice throws to win.
[[7.13|Solution]]


:7.14. Plum blossom poles are a Kung Fu training technique, consisting of &lt;math&gt;n&lt;/math&gt; large posts partially sunk into the ground, with each pole &lt;math&gt;p_i&lt;/math&gt; at position &lt;math&gt;(x_i, y_i)&lt;/math&gt;. Students practice martial arts techniques by stepping from the top of one pole to the top of another pole. In order to keep balance, each step must be more than &lt;math&gt;d&lt;/math&gt; meters but less than &lt;math&gt;2d&lt;/math&gt; meters. Give an efficient algorithm to find a safe path from pole &lt;math&gt;p_s&lt;/math&gt; to &lt;math&gt;p_t&lt;/math&gt; if it exists.


:[[7.15]]. You are planning the seating arrangement for a wedding given a list of guests, &lt;math&gt;V&lt;/math&gt;. For each guest &lt;math&gt;g&lt;/math&gt; you have a list of all other guests who are on bad terms with them. Feelings are reciprocal: if &lt;math&gt;h&lt;/math&gt; is on bad terms with &lt;math&gt;g&lt;/math&gt;, then &lt;math&gt;g&lt;/math&gt; is on bad terms with &lt;math&gt;h&lt;/math&gt;. Your goal is to arrange the seating such that no pair of guests sitting at the same table are on bad terms with each other. There will be only two tables at the wedding. Give an efficient algorithm to find an acceptable seating arrangement if one exists.
[[7.15|Solution]]

===Algorithm Design===

:7.16. The ''square'' of a directed graph &lt;math&gt;G=(V,E)&lt;/math&gt; is the graph &lt;math&gt;G^2=(V,E^2)&lt;/math&gt; such that &lt;math&gt;(u,w) \in E^2&lt;/math&gt; iff there exists &lt;math&gt;v \in V&lt;/math&gt; such that &lt;math&gt;(u,v) \in E&lt;/math&gt; and &lt;math&gt;(v,w) \in E&lt;/math&gt;; i.e., there is a path of exactly two edges from &lt;math&gt;u&lt;/math&gt; to &lt;math&gt;w&lt;/math&gt;.
:Give efficient algorithms for both adjacency lists and matrices.


:[[7.17]]. A ''vertex cover'' of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V'&lt;/math&gt; such that each edge in &lt;math&gt;E&lt;/math&gt; is incident on at least one vertex of &lt;math&gt;V'&lt;/math&gt;.
:(a)Give an efficient algorithm to find a minimum-size vertex cover if &lt;math&gt;G&lt;/math&gt; is a tree.
:(b)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree such that the weight of each vertex is equal to the degree of that vertex. Give an efficient algorithm to find a minimum-weight vertex cover of &lt;math&gt;G&lt;/math&gt;.
:(c)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree with arbitrary weights associated with the vertices. Give an efficient algorithm to find a minimum-weight vertex cover of &lt;math&gt;G&lt;/math&gt;.
[[7.17|Solution]]


:7.18. A ''vertex cover'' of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V' \in V&lt;/math&gt; such that every edge in &lt;math&gt;E&lt;/math&gt; contains at least one vertex from &lt;math&gt;V'&lt;/math&gt;. Delete all the leaves from any depth-first search tree of &lt;math&gt;G&lt;/math&gt;. Must the remaining vertices form a vertex cover of &lt;math&gt;G&lt;/math&gt;? Give a proof or a counterexample.


:[[7.19]]. An ''independent set'' of an undirected graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a set of vertices $U$ such that no edge in &lt;math&gt;E&lt;/math&gt; is incident on two vertices of &lt;math&gt;U&lt;/math&gt;.
:(a)Give an efficient algorithm to find a maximum-size independent set if &lt;math&gt;G&lt;/math&gt; is a tree.
:(b)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree with weights associated with the vertices such that the weight of each vertex is equal to the degree of that vertex. Give an efficient algorithm to find a maximum independent set of &lt;math&gt;G&lt;/math&gt;.
:(c)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree with arbitrary weights associated with the vertices. Give an efficient algorithm to find a maximum independent set of &lt;math&gt;G&lt;/math&gt;.
[[7.19|Solution]]


:7.20. A ''vertex cover'' of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V' \in V&lt;/math&gt; such that every edge in &lt;math&gt;E&lt;/math&gt; contains ''at least one'' vertex from &lt;math&gt;V'&lt;/math&gt;. An ''independent set'' of graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V' \in V&lt;/math&gt; such that no edge in &lt;math&gt;E&lt;/math&gt; contains both vertices from &lt;math&gt;V'&lt;/math&gt;.
:An ''independent vertex cover'' is a subset of vertices that is both an independent set and a vertex cover of &lt;math&gt;G&lt;/math&gt;. Give an efficient algorithm for testing whether &lt;math&gt;G&lt;/math&gt; contains an independent vertex cover. What classical graph problem does this reduce to?


:[[7.21]]]. Consider the problem of determining whether a given undirected graph &lt;math&gt;G=(V,E)&lt;/math&gt; contains a ''triangle'' or cycle of length 3. 
:(a)Give an  &lt;math&gt;O(|V|^3)&lt;/math&gt; to find a triangle if one exists.
:(b)Improve your algorithm to run in time &lt;math&gt;O(|V| \cdot |E|)&lt;/math&gt;. You may assume &lt;math&gt;|V| \leq |E|&lt;/math&gt;. 
:Observe that these bounds gives you time to convert between the adjacency matrix and adjacency list representations of &lt;math&gt;G&lt;/math&gt;.
[[7.21|Solution]]


:7.22. Consider a set of movies &lt;math&gt;M_1, M_2, \ldots, M_k&lt;/math&gt;. There is a set of customers, each one of which indicates the two movies they would like to see this weekend. Movies are shown on Saturday evening and Sunday evening. Multiple movies may be screened at the same time. 
:You must decide which movies should be televised on Saturday and which on Sunday, so that every customer gets to see the two movies they desire. Is there a schedule where each movie is shown at most once? Design an efficient algorithm to find such a schedule if one exists.


:[[7.23]].The ''diameter'' of a tree &lt;math&gt;T=(V,E)&lt;/math&gt; is given by 
&lt;center&gt;&lt;math&gt;\max_{u,v\in V} \delta(u,v)&lt;/math&gt;&lt;/center&gt;
:(where &lt;math&gt;\delta(u,v)&lt;/math&gt; is the number of edges on the path from &lt;math&gt;u&lt;/math&gt; to &lt;math&gt;v&lt;/math&gt;).  Describe an efficient algorithm to compute the diameter of a tree, and show the correctness and analyze the running time of your algorithm.
[[7.23|Solution]]


:7.24. Given an undirected graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges, and an integer &lt;math&gt;k&lt;/math&gt;, give an &lt;math&gt;O(m+n)&lt;/math&gt; algorithm that finds the maximum induced subgraph &lt;math&gt;H&lt;/math&gt; of &lt;math&gt;G&lt;/math&gt; such that each vertex in &lt;math&gt;H&lt;/math&gt; has degree &lt;math&gt;\geq k&lt;/math&gt;, or prove that no such graph exists. An induced subgraph &lt;math&gt;F=(U,R)&lt;/math&gt; of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of &lt;math&gt;U&lt;/math&gt; of the vertices &lt;math&gt;V&lt;/math&gt; of &lt;math&gt;G&lt;/math&gt;, and all edges &lt;math&gt;R&lt;/math&gt; of &lt;math&gt;G&lt;/math&gt; such that both vertices of each edge are in &lt;math&gt;U&lt;/math&gt;.


:[[7.25]]. Let &lt;math&gt;v&lt;/math&gt; and &lt;math&gt;w&lt;/math&gt; be two vertices in a directed graph &lt;math&gt;G=(V,E &lt;/math&gt;. Design a linear-time algorithm to find the ''number'' of different shortest paths (not necessarily vertex disjoint) between &lt;math&gt;v&lt;/math&gt; and &lt;math&gt;w&lt;/math&gt;. Note: the edges in &lt;math&gt;G&lt;/math&gt; are unweighted.
[[7.25|Solution]]


:7.26. Design a linear-time algorithm to eliminate each vertex &lt;math&gt;v&lt;/math&gt; of degree 2 from a graph by replacing edges &lt;math&gt;(u,v)&lt;/math&gt; and &lt;math&gt;(v,w)&lt;/math&gt; by an edge &lt;math&gt;(u,w)&lt;/math&gt;. We also seek to eliminate multiple copies of edges by replacing them with a single edge. Note that removing multiple copies of an edge may create a new vertex of degree 2, which has to be removed, and that removing a vertex of degree 2 may create multiple edges, which also must be removed.

===Directed Graphs===

:[[7.27]]


:7.28


:[[7.29]]


:7.30


:[[7.31]]


:7.32


:[[7.33]]


:7.34


:[[7.35]]


:7.36


:[[7.37]]


===Articulation Vertices===

:7.38


:[[7.39]]


:7.40


:[[7.41]]


===Interview Problems===

:7.42


:[[7.43]]


Back to [[Chapter List]]</text>
      <sha1>881q8fc4az1454tka95n7r7yebvuget</sha1>
    </revision>
    <revision>
      <id>244</id>
      <parentid>243</parentid>
      <timestamp>2020-09-14T17:30:14Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Directed Graphs */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="17560">=Graph Traversal=

===Simulating Graph Algorithms===

:[[7.1]]. For the following graphs &lt;math&gt;G_1&lt;/math&gt; (left) and &lt;math&gt;G_2&lt;/math&gt; (right):
:(see book for figures)

:(a)Report the order of the vertices encountered on a breadth-first search starting from vertex &lt;math&gt;A&lt;/math&gt;. Break all ties by picking the vertices in alphabetical order (i.e., &lt;math&gt;A&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt;).
:(b)Report the order of the vertices encountered on a depth-first search starting from vertex &lt;math&gt;A&lt;/math&gt;. Break all ties by picking the vertices in alphabetical order (i.e., &lt;math&gt;A&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt;).
[[7.1|Solution]]


:7.2. Do a topological sort of the following graph &lt;math&gt;G&lt;/math&gt;:
:(see book for figure)

===Traversal===

:[[7.3]]. Prove that there is a unique path between any pair of vertices in a tree.
[[7.3|Solution]]


:7.4. Prove that in a breadth-first search on a undirected graph &lt;math&gt;G&lt;/math&gt;, every edge is either a tree edge or a cross edge, where &lt;math&gt;x&lt;/math&gt; is neither an ancestor nor descendant of &lt;math&gt;y&lt;/math&gt; in cross edge &lt;math&gt;(x, y)&lt;/math&gt;.


:[[7.5]]. Give a linear algorithm to compute the chromatic number of graphs where each vertex has degree at most 2. Any bipartite graph has a chromatic number of 2. Must such graphs be bipartite?
[[7.5|Solution]]


:7.6. You are given a connected, undirected graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges. Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm to identify an edge you can remove from &lt;math&gt;G&lt;/math&gt; while still leaving &lt;math&gt;G&lt;/math&gt; connected, if one exists. Can you reduce the running time to &lt;math&gt;O(n)&lt;/math&gt;?


:[[7.7]]. In breadth-first and depth-first search, an undiscovered node is marked ''discovered'' when it is first encountered, and marked ''processed'' when it has been completely searched. At any given moment, several nodes might be simultaneously in the ''discovered'' state.
:(a) Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that &lt;math&gt;\Theta(n)&lt;/math&gt; nodes are simultaneously in the ''discovered'' state during a ''breadth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.
:(b) Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that &lt;math&gt;\Theta(n)&lt;/math&gt; nodes are simultaneously in the ''discovered'' state during a ''depth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.
:(c)  Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that at some point &lt;math&gt;\Theta(n)&lt;/math&gt; nodes remain ''undiscovered'', while &lt;math&gt;\Theta(n)&lt;/math&gt; nodes have been ''processed'' during a ''depth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.(Note, there may also be ''discovered'' nodes.)
[[7.7|Solution]]


:7.8. Given pre-order and in-order traversals of a binary tree (discussed in Section 3.4.1), is it possible to reconstruct the tree? If so, sketch an algorithm to do it. If not, give a counterexample. Repeat the problem if you are given the pre-order and post-order traversals.


:[[7.9]]. Present correct and efficient algorithms to convert an undirected graph &lt;math&gt;G&lt;/math&gt; between the following graph data structures. You must give the time complexity of each algorithm, assuming &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges.
:(a)Convert from an adjacency matrix to adjacency lists.
:(b)Convert from an adjacency list to an incidence matrix. An incidence matrix &lt;math&gt;M&lt;/math&gt; has a row for each vertex and a column for each edge, such that &lt;math&gt;M[i,j]=1&lt;/math&gt; if vertex &lt;math&gt;i&lt;/math&gt; is part of edge &lt;math&gt;j&lt;/math&gt;, otherwise &lt;math&gt;M[i,j] = 0&lt;/math&gt;.
:(c)Convert from an incidence matrix to adjacency lists.
[[7.9|Solution]]


:7.10. Suppose an arithmetic expression is given as a tree. Each leaf is an integer and each internal node is one of the standard arithmetical operations &lt;math&gt;(+, -, *, /)&lt;/math&gt;. For example, the expression &lt;math&gt;2+3*4+(3*4)/5&lt;/math&gt; is represented by the tree in Figure 7.17(a). Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for evaluating such an expression, where there are &lt;math&gt;n&lt;/math&gt; nodes in the tree.


:[[7.11]]. Suppose an arithmetic expression is given as a DAG (directed acyclic graph) with common subexpressions removed. Each leaf is an integer and each internal node is one of the standard arithmetical operations &lt;math&gt;(+,-,*,/)&lt;/math&gt;. For example, the expression &lt;math&gt;2+3*4+(3*4)/5&lt;/math&gt; is represented by the DAG in Figure (see book)(b). Give an &lt;math&gt;O(n+m)&lt;/math&gt; algorithm for evaluating such a DAG, where there are &lt;math&gt;n&lt;/math&gt; nodes and &lt;math&gt;m&lt;/math&gt; edges in the DAG. Hint: modify an algorithm for the tree case to achieve the desired efficiency.
[[7.11|Solution]]


:7.12. The war story of Section 7.4 (page 210) describes an algorithm for constructing the dual graph of the triangulation efficiently, although it does not guarantee linear time. Give a worst-case linear algorithm for the problem.

===Applications===

:[[7.13]]. The Chutes and Ladders game has a board with n cells where you seek to travel from cell 1 to cell &lt;math&gt;n&lt;/math&gt;. To move, a player throws a six-sided dice to determine how many cells forward they move. This board also contains chutes and ladders that connect certain pairs of cells. A player who lands on the mouth of a chute immediately falls back down to the cell at the other end. A player who lands on the base of a ladder immediately travels up to the cell at the top of the ladder. Suppose you have rigged the dice to give you full control of the number for each roll. Give an efficient algorithm to find the minimum number of dice throws to win.
[[7.13|Solution]]


:7.14. Plum blossom poles are a Kung Fu training technique, consisting of &lt;math&gt;n&lt;/math&gt; large posts partially sunk into the ground, with each pole &lt;math&gt;p_i&lt;/math&gt; at position &lt;math&gt;(x_i, y_i)&lt;/math&gt;. Students practice martial arts techniques by stepping from the top of one pole to the top of another pole. In order to keep balance, each step must be more than &lt;math&gt;d&lt;/math&gt; meters but less than &lt;math&gt;2d&lt;/math&gt; meters. Give an efficient algorithm to find a safe path from pole &lt;math&gt;p_s&lt;/math&gt; to &lt;math&gt;p_t&lt;/math&gt; if it exists.


:[[7.15]]. You are planning the seating arrangement for a wedding given a list of guests, &lt;math&gt;V&lt;/math&gt;. For each guest &lt;math&gt;g&lt;/math&gt; you have a list of all other guests who are on bad terms with them. Feelings are reciprocal: if &lt;math&gt;h&lt;/math&gt; is on bad terms with &lt;math&gt;g&lt;/math&gt;, then &lt;math&gt;g&lt;/math&gt; is on bad terms with &lt;math&gt;h&lt;/math&gt;. Your goal is to arrange the seating such that no pair of guests sitting at the same table are on bad terms with each other. There will be only two tables at the wedding. Give an efficient algorithm to find an acceptable seating arrangement if one exists.
[[7.15|Solution]]

===Algorithm Design===

:7.16. The ''square'' of a directed graph &lt;math&gt;G=(V,E)&lt;/math&gt; is the graph &lt;math&gt;G^2=(V,E^2)&lt;/math&gt; such that &lt;math&gt;(u,w) \in E^2&lt;/math&gt; iff there exists &lt;math&gt;v \in V&lt;/math&gt; such that &lt;math&gt;(u,v) \in E&lt;/math&gt; and &lt;math&gt;(v,w) \in E&lt;/math&gt;; i.e., there is a path of exactly two edges from &lt;math&gt;u&lt;/math&gt; to &lt;math&gt;w&lt;/math&gt;.
:Give efficient algorithms for both adjacency lists and matrices.


:[[7.17]]. A ''vertex cover'' of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V'&lt;/math&gt; such that each edge in &lt;math&gt;E&lt;/math&gt; is incident on at least one vertex of &lt;math&gt;V'&lt;/math&gt;.
:(a)Give an efficient algorithm to find a minimum-size vertex cover if &lt;math&gt;G&lt;/math&gt; is a tree.
:(b)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree such that the weight of each vertex is equal to the degree of that vertex. Give an efficient algorithm to find a minimum-weight vertex cover of &lt;math&gt;G&lt;/math&gt;.
:(c)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree with arbitrary weights associated with the vertices. Give an efficient algorithm to find a minimum-weight vertex cover of &lt;math&gt;G&lt;/math&gt;.
[[7.17|Solution]]


:7.18. A ''vertex cover'' of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V' \in V&lt;/math&gt; such that every edge in &lt;math&gt;E&lt;/math&gt; contains at least one vertex from &lt;math&gt;V'&lt;/math&gt;. Delete all the leaves from any depth-first search tree of &lt;math&gt;G&lt;/math&gt;. Must the remaining vertices form a vertex cover of &lt;math&gt;G&lt;/math&gt;? Give a proof or a counterexample.


:[[7.19]]. An ''independent set'' of an undirected graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a set of vertices $U$ such that no edge in &lt;math&gt;E&lt;/math&gt; is incident on two vertices of &lt;math&gt;U&lt;/math&gt;.
:(a)Give an efficient algorithm to find a maximum-size independent set if &lt;math&gt;G&lt;/math&gt; is a tree.
:(b)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree with weights associated with the vertices such that the weight of each vertex is equal to the degree of that vertex. Give an efficient algorithm to find a maximum independent set of &lt;math&gt;G&lt;/math&gt;.
:(c)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree with arbitrary weights associated with the vertices. Give an efficient algorithm to find a maximum independent set of &lt;math&gt;G&lt;/math&gt;.
[[7.19|Solution]]


:7.20. A ''vertex cover'' of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V' \in V&lt;/math&gt; such that every edge in &lt;math&gt;E&lt;/math&gt; contains ''at least one'' vertex from &lt;math&gt;V'&lt;/math&gt;. An ''independent set'' of graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V' \in V&lt;/math&gt; such that no edge in &lt;math&gt;E&lt;/math&gt; contains both vertices from &lt;math&gt;V'&lt;/math&gt;.
:An ''independent vertex cover'' is a subset of vertices that is both an independent set and a vertex cover of &lt;math&gt;G&lt;/math&gt;. Give an efficient algorithm for testing whether &lt;math&gt;G&lt;/math&gt; contains an independent vertex cover. What classical graph problem does this reduce to?


:[[7.21]]]. Consider the problem of determining whether a given undirected graph &lt;math&gt;G=(V,E)&lt;/math&gt; contains a ''triangle'' or cycle of length 3. 
:(a)Give an  &lt;math&gt;O(|V|^3)&lt;/math&gt; to find a triangle if one exists.
:(b)Improve your algorithm to run in time &lt;math&gt;O(|V| \cdot |E|)&lt;/math&gt;. You may assume &lt;math&gt;|V| \leq |E|&lt;/math&gt;. 
:Observe that these bounds gives you time to convert between the adjacency matrix and adjacency list representations of &lt;math&gt;G&lt;/math&gt;.
[[7.21|Solution]]


:7.22. Consider a set of movies &lt;math&gt;M_1, M_2, \ldots, M_k&lt;/math&gt;. There is a set of customers, each one of which indicates the two movies they would like to see this weekend. Movies are shown on Saturday evening and Sunday evening. Multiple movies may be screened at the same time. 
:You must decide which movies should be televised on Saturday and which on Sunday, so that every customer gets to see the two movies they desire. Is there a schedule where each movie is shown at most once? Design an efficient algorithm to find such a schedule if one exists.


:[[7.23]].The ''diameter'' of a tree &lt;math&gt;T=(V,E)&lt;/math&gt; is given by 
&lt;center&gt;&lt;math&gt;\max_{u,v\in V} \delta(u,v)&lt;/math&gt;&lt;/center&gt;
:(where &lt;math&gt;\delta(u,v)&lt;/math&gt; is the number of edges on the path from &lt;math&gt;u&lt;/math&gt; to &lt;math&gt;v&lt;/math&gt;).  Describe an efficient algorithm to compute the diameter of a tree, and show the correctness and analyze the running time of your algorithm.
[[7.23|Solution]]


:7.24. Given an undirected graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges, and an integer &lt;math&gt;k&lt;/math&gt;, give an &lt;math&gt;O(m+n)&lt;/math&gt; algorithm that finds the maximum induced subgraph &lt;math&gt;H&lt;/math&gt; of &lt;math&gt;G&lt;/math&gt; such that each vertex in &lt;math&gt;H&lt;/math&gt; has degree &lt;math&gt;\geq k&lt;/math&gt;, or prove that no such graph exists. An induced subgraph &lt;math&gt;F=(U,R)&lt;/math&gt; of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of &lt;math&gt;U&lt;/math&gt; of the vertices &lt;math&gt;V&lt;/math&gt; of &lt;math&gt;G&lt;/math&gt;, and all edges &lt;math&gt;R&lt;/math&gt; of &lt;math&gt;G&lt;/math&gt; such that both vertices of each edge are in &lt;math&gt;U&lt;/math&gt;.


:[[7.25]]. Let &lt;math&gt;v&lt;/math&gt; and &lt;math&gt;w&lt;/math&gt; be two vertices in a directed graph &lt;math&gt;G=(V,E &lt;/math&gt;. Design a linear-time algorithm to find the ''number'' of different shortest paths (not necessarily vertex disjoint) between &lt;math&gt;v&lt;/math&gt; and &lt;math&gt;w&lt;/math&gt;. Note: the edges in &lt;math&gt;G&lt;/math&gt; are unweighted.
[[7.25|Solution]]


:7.26. Design a linear-time algorithm to eliminate each vertex &lt;math&gt;v&lt;/math&gt; of degree 2 from a graph by replacing edges &lt;math&gt;(u,v)&lt;/math&gt; and &lt;math&gt;(v,w)&lt;/math&gt; by an edge &lt;math&gt;(u,w)&lt;/math&gt;. We also seek to eliminate multiple copies of edges by replacing them with a single edge. Note that removing multiple copies of an edge may create a new vertex of degree 2, which has to be removed, and that removing a vertex of degree 2 may create multiple edges, which also must be removed.

===Directed Graphs===

:[[7.27]]. The reverse of a directed graph &lt;math&gt;G = (V, E)&lt;/math&gt; is another directed graph &lt;math&gt;G^R = (V, E^R)&lt;/math&gt; on the same vertex set, but with all edges reversed; that is, &lt;math&gt;E^R = {(v, u) : (u, v) \in E}&lt;/math&gt;. Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm for computing the reverse of an &lt;math&gt;n&lt;/math&gt;-vertex &lt;math&gt;m&lt;/math&gt;-edge graph in adjacency list format.
[[7.27|Solution]]


:7.28. Your job is to arrange &lt;math&gt;n&lt;/math&gt; ill-behaved children in a straight line, facing front. You are given a list of &lt;math&gt;m&lt;/math&gt; statements of the form “&lt;math&gt;i&lt;/math&gt; hates &lt;math&gt;j&lt;/math&gt;.” If &lt;math&gt;i&lt;/math&gt; hates &lt;math&gt;j&lt;/math&gt;, then you do not want to put &lt;math&gt;i&lt;/math&gt; somewhere behind &lt;math&gt;j&lt;/math&gt;, because then &lt;math&gt;i&lt;/math&gt; is capable of throwing something at &lt;math&gt;j&lt;/math&gt;.
:(a) Give an algorithm that orders the line (or says that it is not possible) in &lt;math&gt;O(m + n)&lt;/math&gt; time.
:(b) Suppose instead you want to arrange the children in rows such that if &lt;math&gt;i&lt;/math&gt; hates &lt;math&gt;j&lt;/math&gt;, then &lt;math&gt;i&lt;/math&gt; must be in a lower numbered row than &lt;math&gt;j&lt;/math&gt;. Give an efficient algorithm to find the minimum number of rows needed, if it is possible.


:[[7.29]]. A particular academic program has &lt;math&gt;n&lt;/math&gt; required courses, certain pairs of which have prerequisite relations so that &lt;math&gt;(x, y)&lt;/math&gt; means you must take course &lt;math&gt;x&lt;/math&gt; before &lt;math&gt;y&lt;/math&gt;. How would you analyze the prerequisite pairs to make sure it is possible for people to complete the program?
[[7.29|Solution]]


:7.30. Gotcha-solitaire is a game on a deck with &lt;math&gt;n&lt;/math&gt; distinct cards (all face up) and &lt;math&gt;m&lt;/math&gt; gotcha pairs &lt;math&gt;(i, j)&lt;/math&gt; such that card &lt;math&gt;i&lt;/math&gt; must be played sometime before card &lt;math&gt;j&lt;/math&gt;. You play by sequentially choosing cards, and win if you pick up the entire deck without violating any gotcha pair constraints. Give an efficient algorithm to find a winning pickup order if one exists.


:[[7.31]]. You are given a list of &lt;math&gt;n&lt;/math&gt; words each of length &lt;math&gt;k&lt;/math&gt; in a language you don’t know, although you are told that words are sorted in lexicographic (alphabetical) order. Reconstruct the order of the α alphabet letters (characters) in that language. 
:For example, if the strings are &lt;math&gt;{QQZ, QZZ, XQZ, XQX, XXX}&lt;/math&gt;, the character order must be &lt;math&gt;Q&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt; before &lt;math&gt;X&lt;/math&gt;.
:(a) Give an algorithm to efficiently reconstruct this character order. (Hint: use a graph structure, where each node represents one letter.)
:(b) What is its running time, as a function of &lt;math&gt;n, k&lt;/math&gt;, and &lt;math&gt;\alpha&lt;/math&gt;?
[[7.31|Solution]]


:7.32. A ''weakly connected component'' in a directed graph is a connected component ignoring the direction of the edges. Adding a single directed edge to a directed graph can reduce the number of weakly connected components, but by at most how many components? What about the number of strongly connected components?


:[[7.33]]. Design a linear-time algorithm that, given an undirected graph &lt;math&gt;G&lt;/math&gt; and a particular edge &lt;math&gt;e&lt;/math&gt; in it, determines whether &lt;math&gt;G&lt;/math&gt; has a cycle containing &lt;math&gt;e&lt;/math&gt;.
[[7.33|Solution]]


:7.34. An ''arborescence'' of a directed graph &lt;math&gt;G&lt;/math&gt; is a rooted tree such that there is a directed path from the root to every other vertex in the graph. Give an efficient and correct algorithm to test whether &lt;math&gt;G&lt;/math&gt; contains an arborescence, and its time complexity.


:[[7.35]]. A mother vertex in a directed graph &lt;math&gt;G = (V, E)&lt;/math&gt; is a vertex &lt;math&gt;v&lt;/math&gt; such that all other vertices &lt;math&gt;G&lt;/math&gt; can be reached by a directed path from &lt;math&gt;v&lt;/math&gt;. 
:(a) Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm to test whether a given vertex &lt;math&gt;v&lt;/math&gt; is a mother of &lt;math&gt;G&lt;/math&gt;, where &lt;math&gt;n = |V|&lt;/math&gt; and &lt;math&gt;m = |E|&lt;/math&gt;. 
:(b) Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm to test whether graph &lt;math&gt;G&lt;/math&gt; contains a mother vertex.
[[7.35|Solution]]


:7.36. Let &lt;math&gt;G&lt;/math&gt; be a directed graph. We say that &lt;math&gt;G&lt;/math&gt; is ''k-cyclic'' if every (not necessarily simple) cycle in &lt;math&gt;G&lt;/math&gt; contains at most &lt;math&gt;k&lt;/math&gt; distinct nodes. Give a linear-time algorithm to determine if a directed graph &lt;math&gt;G&lt;/math&gt; is &lt;math&gt;k&lt;/math&gt;-cyclic, where &lt;math&gt;G&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt; are given as inputs. Justify the correctness and running time of your algorithm.


:[[7.37]]. A ''tournament'' is a directed graph formed by taking the complete undirected graph and assigning arbitrary directions on the edges—that is, a graph &lt;math&gt;G = (V, E)&lt;/math&gt; such that for all &lt;math&gt;u,v \in V&lt;/math&gt;, exactly one of &lt;math&gt;(u, v)&lt;/math&gt; or &lt;math&gt;(v, u)&lt;/math&gt; is in &lt;math&gt;E&lt;/math&gt;. Show that every tournament has a Hamiltonian path—that is, a path that visits every vertex exactly once. Give an algorithm to find this path.
[[7.37|Solution]]

===Articulation Vertices===

:7.38


:[[7.39]]


:7.40


:[[7.41]]


===Interview Problems===

:7.42


:[[7.43]]


Back to [[Chapter List]]</text>
      <sha1>pw89h3vdhcgevqopacpj5uzexozvxod</sha1>
    </revision>
    <revision>
      <id>245</id>
      <parentid>244</parentid>
      <timestamp>2020-09-14T17:42:09Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Articulation Vertices */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="18972">=Graph Traversal=

===Simulating Graph Algorithms===

:[[7.1]]. For the following graphs &lt;math&gt;G_1&lt;/math&gt; (left) and &lt;math&gt;G_2&lt;/math&gt; (right):
:(see book for figures)

:(a)Report the order of the vertices encountered on a breadth-first search starting from vertex &lt;math&gt;A&lt;/math&gt;. Break all ties by picking the vertices in alphabetical order (i.e., &lt;math&gt;A&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt;).
:(b)Report the order of the vertices encountered on a depth-first search starting from vertex &lt;math&gt;A&lt;/math&gt;. Break all ties by picking the vertices in alphabetical order (i.e., &lt;math&gt;A&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt;).
[[7.1|Solution]]


:7.2. Do a topological sort of the following graph &lt;math&gt;G&lt;/math&gt;:
:(see book for figure)

===Traversal===

:[[7.3]]. Prove that there is a unique path between any pair of vertices in a tree.
[[7.3|Solution]]


:7.4. Prove that in a breadth-first search on a undirected graph &lt;math&gt;G&lt;/math&gt;, every edge is either a tree edge or a cross edge, where &lt;math&gt;x&lt;/math&gt; is neither an ancestor nor descendant of &lt;math&gt;y&lt;/math&gt; in cross edge &lt;math&gt;(x, y)&lt;/math&gt;.


:[[7.5]]. Give a linear algorithm to compute the chromatic number of graphs where each vertex has degree at most 2. Any bipartite graph has a chromatic number of 2. Must such graphs be bipartite?
[[7.5|Solution]]


:7.6. You are given a connected, undirected graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges. Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm to identify an edge you can remove from &lt;math&gt;G&lt;/math&gt; while still leaving &lt;math&gt;G&lt;/math&gt; connected, if one exists. Can you reduce the running time to &lt;math&gt;O(n)&lt;/math&gt;?


:[[7.7]]. In breadth-first and depth-first search, an undiscovered node is marked ''discovered'' when it is first encountered, and marked ''processed'' when it has been completely searched. At any given moment, several nodes might be simultaneously in the ''discovered'' state.
:(a) Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that &lt;math&gt;\Theta(n)&lt;/math&gt; nodes are simultaneously in the ''discovered'' state during a ''breadth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.
:(b) Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that &lt;math&gt;\Theta(n)&lt;/math&gt; nodes are simultaneously in the ''discovered'' state during a ''depth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.
:(c)  Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that at some point &lt;math&gt;\Theta(n)&lt;/math&gt; nodes remain ''undiscovered'', while &lt;math&gt;\Theta(n)&lt;/math&gt; nodes have been ''processed'' during a ''depth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.(Note, there may also be ''discovered'' nodes.)
[[7.7|Solution]]


:7.8. Given pre-order and in-order traversals of a binary tree (discussed in Section 3.4.1), is it possible to reconstruct the tree? If so, sketch an algorithm to do it. If not, give a counterexample. Repeat the problem if you are given the pre-order and post-order traversals.


:[[7.9]]. Present correct and efficient algorithms to convert an undirected graph &lt;math&gt;G&lt;/math&gt; between the following graph data structures. You must give the time complexity of each algorithm, assuming &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges.
:(a)Convert from an adjacency matrix to adjacency lists.
:(b)Convert from an adjacency list to an incidence matrix. An incidence matrix &lt;math&gt;M&lt;/math&gt; has a row for each vertex and a column for each edge, such that &lt;math&gt;M[i,j]=1&lt;/math&gt; if vertex &lt;math&gt;i&lt;/math&gt; is part of edge &lt;math&gt;j&lt;/math&gt;, otherwise &lt;math&gt;M[i,j] = 0&lt;/math&gt;.
:(c)Convert from an incidence matrix to adjacency lists.
[[7.9|Solution]]


:7.10. Suppose an arithmetic expression is given as a tree. Each leaf is an integer and each internal node is one of the standard arithmetical operations &lt;math&gt;(+, -, *, /)&lt;/math&gt;. For example, the expression &lt;math&gt;2+3*4+(3*4)/5&lt;/math&gt; is represented by the tree in Figure 7.17(a). Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for evaluating such an expression, where there are &lt;math&gt;n&lt;/math&gt; nodes in the tree.


:[[7.11]]. Suppose an arithmetic expression is given as a DAG (directed acyclic graph) with common subexpressions removed. Each leaf is an integer and each internal node is one of the standard arithmetical operations &lt;math&gt;(+,-,*,/)&lt;/math&gt;. For example, the expression &lt;math&gt;2+3*4+(3*4)/5&lt;/math&gt; is represented by the DAG in Figure (see book)(b). Give an &lt;math&gt;O(n+m)&lt;/math&gt; algorithm for evaluating such a DAG, where there are &lt;math&gt;n&lt;/math&gt; nodes and &lt;math&gt;m&lt;/math&gt; edges in the DAG. Hint: modify an algorithm for the tree case to achieve the desired efficiency.
[[7.11|Solution]]


:7.12. The war story of Section 7.4 (page 210) describes an algorithm for constructing the dual graph of the triangulation efficiently, although it does not guarantee linear time. Give a worst-case linear algorithm for the problem.

===Applications===

:[[7.13]]. The Chutes and Ladders game has a board with n cells where you seek to travel from cell 1 to cell &lt;math&gt;n&lt;/math&gt;. To move, a player throws a six-sided dice to determine how many cells forward they move. This board also contains chutes and ladders that connect certain pairs of cells. A player who lands on the mouth of a chute immediately falls back down to the cell at the other end. A player who lands on the base of a ladder immediately travels up to the cell at the top of the ladder. Suppose you have rigged the dice to give you full control of the number for each roll. Give an efficient algorithm to find the minimum number of dice throws to win.
[[7.13|Solution]]


:7.14. Plum blossom poles are a Kung Fu training technique, consisting of &lt;math&gt;n&lt;/math&gt; large posts partially sunk into the ground, with each pole &lt;math&gt;p_i&lt;/math&gt; at position &lt;math&gt;(x_i, y_i)&lt;/math&gt;. Students practice martial arts techniques by stepping from the top of one pole to the top of another pole. In order to keep balance, each step must be more than &lt;math&gt;d&lt;/math&gt; meters but less than &lt;math&gt;2d&lt;/math&gt; meters. Give an efficient algorithm to find a safe path from pole &lt;math&gt;p_s&lt;/math&gt; to &lt;math&gt;p_t&lt;/math&gt; if it exists.


:[[7.15]]. You are planning the seating arrangement for a wedding given a list of guests, &lt;math&gt;V&lt;/math&gt;. For each guest &lt;math&gt;g&lt;/math&gt; you have a list of all other guests who are on bad terms with them. Feelings are reciprocal: if &lt;math&gt;h&lt;/math&gt; is on bad terms with &lt;math&gt;g&lt;/math&gt;, then &lt;math&gt;g&lt;/math&gt; is on bad terms with &lt;math&gt;h&lt;/math&gt;. Your goal is to arrange the seating such that no pair of guests sitting at the same table are on bad terms with each other. There will be only two tables at the wedding. Give an efficient algorithm to find an acceptable seating arrangement if one exists.
[[7.15|Solution]]

===Algorithm Design===

:7.16. The ''square'' of a directed graph &lt;math&gt;G=(V,E)&lt;/math&gt; is the graph &lt;math&gt;G^2=(V,E^2)&lt;/math&gt; such that &lt;math&gt;(u,w) \in E^2&lt;/math&gt; iff there exists &lt;math&gt;v \in V&lt;/math&gt; such that &lt;math&gt;(u,v) \in E&lt;/math&gt; and &lt;math&gt;(v,w) \in E&lt;/math&gt;; i.e., there is a path of exactly two edges from &lt;math&gt;u&lt;/math&gt; to &lt;math&gt;w&lt;/math&gt;.
:Give efficient algorithms for both adjacency lists and matrices.


:[[7.17]]. A ''vertex cover'' of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V'&lt;/math&gt; such that each edge in &lt;math&gt;E&lt;/math&gt; is incident on at least one vertex of &lt;math&gt;V'&lt;/math&gt;.
:(a)Give an efficient algorithm to find a minimum-size vertex cover if &lt;math&gt;G&lt;/math&gt; is a tree.
:(b)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree such that the weight of each vertex is equal to the degree of that vertex. Give an efficient algorithm to find a minimum-weight vertex cover of &lt;math&gt;G&lt;/math&gt;.
:(c)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree with arbitrary weights associated with the vertices. Give an efficient algorithm to find a minimum-weight vertex cover of &lt;math&gt;G&lt;/math&gt;.
[[7.17|Solution]]


:7.18. A ''vertex cover'' of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V' \in V&lt;/math&gt; such that every edge in &lt;math&gt;E&lt;/math&gt; contains at least one vertex from &lt;math&gt;V'&lt;/math&gt;. Delete all the leaves from any depth-first search tree of &lt;math&gt;G&lt;/math&gt;. Must the remaining vertices form a vertex cover of &lt;math&gt;G&lt;/math&gt;? Give a proof or a counterexample.


:[[7.19]]. An ''independent set'' of an undirected graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a set of vertices $U$ such that no edge in &lt;math&gt;E&lt;/math&gt; is incident on two vertices of &lt;math&gt;U&lt;/math&gt;.
:(a)Give an efficient algorithm to find a maximum-size independent set if &lt;math&gt;G&lt;/math&gt; is a tree.
:(b)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree with weights associated with the vertices such that the weight of each vertex is equal to the degree of that vertex. Give an efficient algorithm to find a maximum independent set of &lt;math&gt;G&lt;/math&gt;.
:(c)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree with arbitrary weights associated with the vertices. Give an efficient algorithm to find a maximum independent set of &lt;math&gt;G&lt;/math&gt;.
[[7.19|Solution]]


:7.20. A ''vertex cover'' of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V' \in V&lt;/math&gt; such that every edge in &lt;math&gt;E&lt;/math&gt; contains ''at least one'' vertex from &lt;math&gt;V'&lt;/math&gt;. An ''independent set'' of graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V' \in V&lt;/math&gt; such that no edge in &lt;math&gt;E&lt;/math&gt; contains both vertices from &lt;math&gt;V'&lt;/math&gt;.
:An ''independent vertex cover'' is a subset of vertices that is both an independent set and a vertex cover of &lt;math&gt;G&lt;/math&gt;. Give an efficient algorithm for testing whether &lt;math&gt;G&lt;/math&gt; contains an independent vertex cover. What classical graph problem does this reduce to?


:[[7.21]]]. Consider the problem of determining whether a given undirected graph &lt;math&gt;G=(V,E)&lt;/math&gt; contains a ''triangle'' or cycle of length 3. 
:(a)Give an  &lt;math&gt;O(|V|^3)&lt;/math&gt; to find a triangle if one exists.
:(b)Improve your algorithm to run in time &lt;math&gt;O(|V| \cdot |E|)&lt;/math&gt;. You may assume &lt;math&gt;|V| \leq |E|&lt;/math&gt;. 
:Observe that these bounds gives you time to convert between the adjacency matrix and adjacency list representations of &lt;math&gt;G&lt;/math&gt;.
[[7.21|Solution]]


:7.22. Consider a set of movies &lt;math&gt;M_1, M_2, \ldots, M_k&lt;/math&gt;. There is a set of customers, each one of which indicates the two movies they would like to see this weekend. Movies are shown on Saturday evening and Sunday evening. Multiple movies may be screened at the same time. 
:You must decide which movies should be televised on Saturday and which on Sunday, so that every customer gets to see the two movies they desire. Is there a schedule where each movie is shown at most once? Design an efficient algorithm to find such a schedule if one exists.


:[[7.23]].The ''diameter'' of a tree &lt;math&gt;T=(V,E)&lt;/math&gt; is given by 
&lt;center&gt;&lt;math&gt;\max_{u,v\in V} \delta(u,v)&lt;/math&gt;&lt;/center&gt;
:(where &lt;math&gt;\delta(u,v)&lt;/math&gt; is the number of edges on the path from &lt;math&gt;u&lt;/math&gt; to &lt;math&gt;v&lt;/math&gt;).  Describe an efficient algorithm to compute the diameter of a tree, and show the correctness and analyze the running time of your algorithm.
[[7.23|Solution]]


:7.24. Given an undirected graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges, and an integer &lt;math&gt;k&lt;/math&gt;, give an &lt;math&gt;O(m+n)&lt;/math&gt; algorithm that finds the maximum induced subgraph &lt;math&gt;H&lt;/math&gt; of &lt;math&gt;G&lt;/math&gt; such that each vertex in &lt;math&gt;H&lt;/math&gt; has degree &lt;math&gt;\geq k&lt;/math&gt;, or prove that no such graph exists. An induced subgraph &lt;math&gt;F=(U,R)&lt;/math&gt; of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of &lt;math&gt;U&lt;/math&gt; of the vertices &lt;math&gt;V&lt;/math&gt; of &lt;math&gt;G&lt;/math&gt;, and all edges &lt;math&gt;R&lt;/math&gt; of &lt;math&gt;G&lt;/math&gt; such that both vertices of each edge are in &lt;math&gt;U&lt;/math&gt;.


:[[7.25]]. Let &lt;math&gt;v&lt;/math&gt; and &lt;math&gt;w&lt;/math&gt; be two vertices in a directed graph &lt;math&gt;G=(V,E &lt;/math&gt;. Design a linear-time algorithm to find the ''number'' of different shortest paths (not necessarily vertex disjoint) between &lt;math&gt;v&lt;/math&gt; and &lt;math&gt;w&lt;/math&gt;. Note: the edges in &lt;math&gt;G&lt;/math&gt; are unweighted.
[[7.25|Solution]]


:7.26. Design a linear-time algorithm to eliminate each vertex &lt;math&gt;v&lt;/math&gt; of degree 2 from a graph by replacing edges &lt;math&gt;(u,v)&lt;/math&gt; and &lt;math&gt;(v,w)&lt;/math&gt; by an edge &lt;math&gt;(u,w)&lt;/math&gt;. We also seek to eliminate multiple copies of edges by replacing them with a single edge. Note that removing multiple copies of an edge may create a new vertex of degree 2, which has to be removed, and that removing a vertex of degree 2 may create multiple edges, which also must be removed.

===Directed Graphs===

:[[7.27]]. The reverse of a directed graph &lt;math&gt;G = (V, E)&lt;/math&gt; is another directed graph &lt;math&gt;G^R = (V, E^R)&lt;/math&gt; on the same vertex set, but with all edges reversed; that is, &lt;math&gt;E^R = {(v, u) : (u, v) \in E}&lt;/math&gt;. Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm for computing the reverse of an &lt;math&gt;n&lt;/math&gt;-vertex &lt;math&gt;m&lt;/math&gt;-edge graph in adjacency list format.
[[7.27|Solution]]


:7.28. Your job is to arrange &lt;math&gt;n&lt;/math&gt; ill-behaved children in a straight line, facing front. You are given a list of &lt;math&gt;m&lt;/math&gt; statements of the form “&lt;math&gt;i&lt;/math&gt; hates &lt;math&gt;j&lt;/math&gt;.” If &lt;math&gt;i&lt;/math&gt; hates &lt;math&gt;j&lt;/math&gt;, then you do not want to put &lt;math&gt;i&lt;/math&gt; somewhere behind &lt;math&gt;j&lt;/math&gt;, because then &lt;math&gt;i&lt;/math&gt; is capable of throwing something at &lt;math&gt;j&lt;/math&gt;.
:(a) Give an algorithm that orders the line (or says that it is not possible) in &lt;math&gt;O(m + n)&lt;/math&gt; time.
:(b) Suppose instead you want to arrange the children in rows such that if &lt;math&gt;i&lt;/math&gt; hates &lt;math&gt;j&lt;/math&gt;, then &lt;math&gt;i&lt;/math&gt; must be in a lower numbered row than &lt;math&gt;j&lt;/math&gt;. Give an efficient algorithm to find the minimum number of rows needed, if it is possible.


:[[7.29]]. A particular academic program has &lt;math&gt;n&lt;/math&gt; required courses, certain pairs of which have prerequisite relations so that &lt;math&gt;(x, y)&lt;/math&gt; means you must take course &lt;math&gt;x&lt;/math&gt; before &lt;math&gt;y&lt;/math&gt;. How would you analyze the prerequisite pairs to make sure it is possible for people to complete the program?
[[7.29|Solution]]


:7.30. Gotcha-solitaire is a game on a deck with &lt;math&gt;n&lt;/math&gt; distinct cards (all face up) and &lt;math&gt;m&lt;/math&gt; gotcha pairs &lt;math&gt;(i, j)&lt;/math&gt; such that card &lt;math&gt;i&lt;/math&gt; must be played sometime before card &lt;math&gt;j&lt;/math&gt;. You play by sequentially choosing cards, and win if you pick up the entire deck without violating any gotcha pair constraints. Give an efficient algorithm to find a winning pickup order if one exists.


:[[7.31]]. You are given a list of &lt;math&gt;n&lt;/math&gt; words each of length &lt;math&gt;k&lt;/math&gt; in a language you don’t know, although you are told that words are sorted in lexicographic (alphabetical) order. Reconstruct the order of the α alphabet letters (characters) in that language. 
:For example, if the strings are &lt;math&gt;{QQZ, QZZ, XQZ, XQX, XXX}&lt;/math&gt;, the character order must be &lt;math&gt;Q&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt; before &lt;math&gt;X&lt;/math&gt;.
:(a) Give an algorithm to efficiently reconstruct this character order. (Hint: use a graph structure, where each node represents one letter.)
:(b) What is its running time, as a function of &lt;math&gt;n, k&lt;/math&gt;, and &lt;math&gt;\alpha&lt;/math&gt;?
[[7.31|Solution]]


:7.32. A ''weakly connected component'' in a directed graph is a connected component ignoring the direction of the edges. Adding a single directed edge to a directed graph can reduce the number of weakly connected components, but by at most how many components? What about the number of strongly connected components?


:[[7.33]]. Design a linear-time algorithm that, given an undirected graph &lt;math&gt;G&lt;/math&gt; and a particular edge &lt;math&gt;e&lt;/math&gt; in it, determines whether &lt;math&gt;G&lt;/math&gt; has a cycle containing &lt;math&gt;e&lt;/math&gt;.
[[7.33|Solution]]


:7.34. An ''arborescence'' of a directed graph &lt;math&gt;G&lt;/math&gt; is a rooted tree such that there is a directed path from the root to every other vertex in the graph. Give an efficient and correct algorithm to test whether &lt;math&gt;G&lt;/math&gt; contains an arborescence, and its time complexity.


:[[7.35]]. A mother vertex in a directed graph &lt;math&gt;G = (V, E)&lt;/math&gt; is a vertex &lt;math&gt;v&lt;/math&gt; such that all other vertices &lt;math&gt;G&lt;/math&gt; can be reached by a directed path from &lt;math&gt;v&lt;/math&gt;. 
:(a) Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm to test whether a given vertex &lt;math&gt;v&lt;/math&gt; is a mother of &lt;math&gt;G&lt;/math&gt;, where &lt;math&gt;n = |V|&lt;/math&gt; and &lt;math&gt;m = |E|&lt;/math&gt;. 
:(b) Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm to test whether graph &lt;math&gt;G&lt;/math&gt; contains a mother vertex.
[[7.35|Solution]]


:7.36. Let &lt;math&gt;G&lt;/math&gt; be a directed graph. We say that &lt;math&gt;G&lt;/math&gt; is ''k-cyclic'' if every (not necessarily simple) cycle in &lt;math&gt;G&lt;/math&gt; contains at most &lt;math&gt;k&lt;/math&gt; distinct nodes. Give a linear-time algorithm to determine if a directed graph &lt;math&gt;G&lt;/math&gt; is &lt;math&gt;k&lt;/math&gt;-cyclic, where &lt;math&gt;G&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt; are given as inputs. Justify the correctness and running time of your algorithm.


:[[7.37]]. A ''tournament'' is a directed graph formed by taking the complete undirected graph and assigning arbitrary directions on the edges—that is, a graph &lt;math&gt;G = (V, E)&lt;/math&gt; such that for all &lt;math&gt;u,v \in V&lt;/math&gt;, exactly one of &lt;math&gt;(u, v)&lt;/math&gt; or &lt;math&gt;(v, u)&lt;/math&gt; is in &lt;math&gt;E&lt;/math&gt;. Show that every tournament has a Hamiltonian path—that is, a path that visits every vertex exactly once. Give an algorithm to find this path.
[[7.37|Solution]]

===Articulation Vertices===

:7.38. An articulation vertex of a connected graph &lt;math&gt;G&lt;math&gt; is a vertex whose deletion disconnects &lt;math&gt;G&lt;/math&gt;. Let &lt;math&gt;G&lt;/math&gt; be a graph with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges. Give a simple &lt;math&gt;O(n+m)&lt;/math&gt; algorithm for finding a vertex of &lt;math&gt;G&lt;/math&gt; that is not an articulation vertex—that is, whose deletion does not disconnect &lt;math&gt;G&lt;/math&gt;.


:[[7.39]]. Following up on the previous problem, give an &lt;math&gt;O(n+m)&lt;/math&gt; algorithm that finds a deletion order for the &lt;math&gt;n&lt;/math&gt; vertices such that no deletion disconnects the graph. (Hint: think DFS/BFS.)
[[7.39|Solution]]


:7.40. Suppose &lt;math&gt;G&lt;/math&gt; is a connected undirected graph. An edge &lt;math&gt;e&lt;/math&gt; whose removal disconnects the graph is called a bridge. Must every bridge &lt;math&gt;e&lt;/math&gt; be an edge in a depth-first search tree of &lt;math&gt;G&lt;/math&gt;? Give a proof or a counterexample.


:[[7.41]]. A city that only has two-way streets has decided to change them all into one-way streets. They want to ensure that the new network is strongly connected so everyone can legally drive anywhere in the city and back.
:(a) Let &lt;math&gt;G&lt;/math&gt; be the original undirected graph. Prove that there is a way to properly orient/direct the edges of &lt;math&gt;G&lt;/math&gt; provided &lt;math&gt;G&lt;/math&gt; does not contain a bridge.
:(b) Give an efficient algorithm to orient the edges of a bridgeless graph &lt;math&gt;G&lt;/math&gt; so the result is strongly connected.
[[7.41|Solution]]

===Interview Problems===

:7.42


:[[7.43]]


Back to [[Chapter List]]</text>
      <sha1>oh7gx5ojtqk5w59sp3q1pnjug6zdfbq</sha1>
    </revision>
    <revision>
      <id>246</id>
      <parentid>245</parentid>
      <timestamp>2020-09-14T17:42:51Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Interview Problems */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="19152">=Graph Traversal=

===Simulating Graph Algorithms===

:[[7.1]]. For the following graphs &lt;math&gt;G_1&lt;/math&gt; (left) and &lt;math&gt;G_2&lt;/math&gt; (right):
:(see book for figures)

:(a)Report the order of the vertices encountered on a breadth-first search starting from vertex &lt;math&gt;A&lt;/math&gt;. Break all ties by picking the vertices in alphabetical order (i.e., &lt;math&gt;A&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt;).
:(b)Report the order of the vertices encountered on a depth-first search starting from vertex &lt;math&gt;A&lt;/math&gt;. Break all ties by picking the vertices in alphabetical order (i.e., &lt;math&gt;A&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt;).
[[7.1|Solution]]


:7.2. Do a topological sort of the following graph &lt;math&gt;G&lt;/math&gt;:
:(see book for figure)

===Traversal===

:[[7.3]]. Prove that there is a unique path between any pair of vertices in a tree.
[[7.3|Solution]]


:7.4. Prove that in a breadth-first search on a undirected graph &lt;math&gt;G&lt;/math&gt;, every edge is either a tree edge or a cross edge, where &lt;math&gt;x&lt;/math&gt; is neither an ancestor nor descendant of &lt;math&gt;y&lt;/math&gt; in cross edge &lt;math&gt;(x, y)&lt;/math&gt;.


:[[7.5]]. Give a linear algorithm to compute the chromatic number of graphs where each vertex has degree at most 2. Any bipartite graph has a chromatic number of 2. Must such graphs be bipartite?
[[7.5|Solution]]


:7.6. You are given a connected, undirected graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges. Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm to identify an edge you can remove from &lt;math&gt;G&lt;/math&gt; while still leaving &lt;math&gt;G&lt;/math&gt; connected, if one exists. Can you reduce the running time to &lt;math&gt;O(n)&lt;/math&gt;?


:[[7.7]]. In breadth-first and depth-first search, an undiscovered node is marked ''discovered'' when it is first encountered, and marked ''processed'' when it has been completely searched. At any given moment, several nodes might be simultaneously in the ''discovered'' state.
:(a) Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that &lt;math&gt;\Theta(n)&lt;/math&gt; nodes are simultaneously in the ''discovered'' state during a ''breadth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.
:(b) Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that &lt;math&gt;\Theta(n)&lt;/math&gt; nodes are simultaneously in the ''discovered'' state during a ''depth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.
:(c)  Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that at some point &lt;math&gt;\Theta(n)&lt;/math&gt; nodes remain ''undiscovered'', while &lt;math&gt;\Theta(n)&lt;/math&gt; nodes have been ''processed'' during a ''depth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.(Note, there may also be ''discovered'' nodes.)
[[7.7|Solution]]


:7.8. Given pre-order and in-order traversals of a binary tree (discussed in Section 3.4.1), is it possible to reconstruct the tree? If so, sketch an algorithm to do it. If not, give a counterexample. Repeat the problem if you are given the pre-order and post-order traversals.


:[[7.9]]. Present correct and efficient algorithms to convert an undirected graph &lt;math&gt;G&lt;/math&gt; between the following graph data structures. You must give the time complexity of each algorithm, assuming &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges.
:(a)Convert from an adjacency matrix to adjacency lists.
:(b)Convert from an adjacency list to an incidence matrix. An incidence matrix &lt;math&gt;M&lt;/math&gt; has a row for each vertex and a column for each edge, such that &lt;math&gt;M[i,j]=1&lt;/math&gt; if vertex &lt;math&gt;i&lt;/math&gt; is part of edge &lt;math&gt;j&lt;/math&gt;, otherwise &lt;math&gt;M[i,j] = 0&lt;/math&gt;.
:(c)Convert from an incidence matrix to adjacency lists.
[[7.9|Solution]]


:7.10. Suppose an arithmetic expression is given as a tree. Each leaf is an integer and each internal node is one of the standard arithmetical operations &lt;math&gt;(+, -, *, /)&lt;/math&gt;. For example, the expression &lt;math&gt;2+3*4+(3*4)/5&lt;/math&gt; is represented by the tree in Figure 7.17(a). Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for evaluating such an expression, where there are &lt;math&gt;n&lt;/math&gt; nodes in the tree.


:[[7.11]]. Suppose an arithmetic expression is given as a DAG (directed acyclic graph) with common subexpressions removed. Each leaf is an integer and each internal node is one of the standard arithmetical operations &lt;math&gt;(+,-,*,/)&lt;/math&gt;. For example, the expression &lt;math&gt;2+3*4+(3*4)/5&lt;/math&gt; is represented by the DAG in Figure (see book)(b). Give an &lt;math&gt;O(n+m)&lt;/math&gt; algorithm for evaluating such a DAG, where there are &lt;math&gt;n&lt;/math&gt; nodes and &lt;math&gt;m&lt;/math&gt; edges in the DAG. Hint: modify an algorithm for the tree case to achieve the desired efficiency.
[[7.11|Solution]]


:7.12. The war story of Section 7.4 (page 210) describes an algorithm for constructing the dual graph of the triangulation efficiently, although it does not guarantee linear time. Give a worst-case linear algorithm for the problem.

===Applications===

:[[7.13]]. The Chutes and Ladders game has a board with n cells where you seek to travel from cell 1 to cell &lt;math&gt;n&lt;/math&gt;. To move, a player throws a six-sided dice to determine how many cells forward they move. This board also contains chutes and ladders that connect certain pairs of cells. A player who lands on the mouth of a chute immediately falls back down to the cell at the other end. A player who lands on the base of a ladder immediately travels up to the cell at the top of the ladder. Suppose you have rigged the dice to give you full control of the number for each roll. Give an efficient algorithm to find the minimum number of dice throws to win.
[[7.13|Solution]]


:7.14. Plum blossom poles are a Kung Fu training technique, consisting of &lt;math&gt;n&lt;/math&gt; large posts partially sunk into the ground, with each pole &lt;math&gt;p_i&lt;/math&gt; at position &lt;math&gt;(x_i, y_i)&lt;/math&gt;. Students practice martial arts techniques by stepping from the top of one pole to the top of another pole. In order to keep balance, each step must be more than &lt;math&gt;d&lt;/math&gt; meters but less than &lt;math&gt;2d&lt;/math&gt; meters. Give an efficient algorithm to find a safe path from pole &lt;math&gt;p_s&lt;/math&gt; to &lt;math&gt;p_t&lt;/math&gt; if it exists.


:[[7.15]]. You are planning the seating arrangement for a wedding given a list of guests, &lt;math&gt;V&lt;/math&gt;. For each guest &lt;math&gt;g&lt;/math&gt; you have a list of all other guests who are on bad terms with them. Feelings are reciprocal: if &lt;math&gt;h&lt;/math&gt; is on bad terms with &lt;math&gt;g&lt;/math&gt;, then &lt;math&gt;g&lt;/math&gt; is on bad terms with &lt;math&gt;h&lt;/math&gt;. Your goal is to arrange the seating such that no pair of guests sitting at the same table are on bad terms with each other. There will be only two tables at the wedding. Give an efficient algorithm to find an acceptable seating arrangement if one exists.
[[7.15|Solution]]

===Algorithm Design===

:7.16. The ''square'' of a directed graph &lt;math&gt;G=(V,E)&lt;/math&gt; is the graph &lt;math&gt;G^2=(V,E^2)&lt;/math&gt; such that &lt;math&gt;(u,w) \in E^2&lt;/math&gt; iff there exists &lt;math&gt;v \in V&lt;/math&gt; such that &lt;math&gt;(u,v) \in E&lt;/math&gt; and &lt;math&gt;(v,w) \in E&lt;/math&gt;; i.e., there is a path of exactly two edges from &lt;math&gt;u&lt;/math&gt; to &lt;math&gt;w&lt;/math&gt;.
:Give efficient algorithms for both adjacency lists and matrices.


:[[7.17]]. A ''vertex cover'' of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V'&lt;/math&gt; such that each edge in &lt;math&gt;E&lt;/math&gt; is incident on at least one vertex of &lt;math&gt;V'&lt;/math&gt;.
:(a)Give an efficient algorithm to find a minimum-size vertex cover if &lt;math&gt;G&lt;/math&gt; is a tree.
:(b)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree such that the weight of each vertex is equal to the degree of that vertex. Give an efficient algorithm to find a minimum-weight vertex cover of &lt;math&gt;G&lt;/math&gt;.
:(c)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree with arbitrary weights associated with the vertices. Give an efficient algorithm to find a minimum-weight vertex cover of &lt;math&gt;G&lt;/math&gt;.
[[7.17|Solution]]


:7.18. A ''vertex cover'' of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V' \in V&lt;/math&gt; such that every edge in &lt;math&gt;E&lt;/math&gt; contains at least one vertex from &lt;math&gt;V'&lt;/math&gt;. Delete all the leaves from any depth-first search tree of &lt;math&gt;G&lt;/math&gt;. Must the remaining vertices form a vertex cover of &lt;math&gt;G&lt;/math&gt;? Give a proof or a counterexample.


:[[7.19]]. An ''independent set'' of an undirected graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a set of vertices $U$ such that no edge in &lt;math&gt;E&lt;/math&gt; is incident on two vertices of &lt;math&gt;U&lt;/math&gt;.
:(a)Give an efficient algorithm to find a maximum-size independent set if &lt;math&gt;G&lt;/math&gt; is a tree.
:(b)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree with weights associated with the vertices such that the weight of each vertex is equal to the degree of that vertex. Give an efficient algorithm to find a maximum independent set of &lt;math&gt;G&lt;/math&gt;.
:(c)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree with arbitrary weights associated with the vertices. Give an efficient algorithm to find a maximum independent set of &lt;math&gt;G&lt;/math&gt;.
[[7.19|Solution]]


:7.20. A ''vertex cover'' of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V' \in V&lt;/math&gt; such that every edge in &lt;math&gt;E&lt;/math&gt; contains ''at least one'' vertex from &lt;math&gt;V'&lt;/math&gt;. An ''independent set'' of graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V' \in V&lt;/math&gt; such that no edge in &lt;math&gt;E&lt;/math&gt; contains both vertices from &lt;math&gt;V'&lt;/math&gt;.
:An ''independent vertex cover'' is a subset of vertices that is both an independent set and a vertex cover of &lt;math&gt;G&lt;/math&gt;. Give an efficient algorithm for testing whether &lt;math&gt;G&lt;/math&gt; contains an independent vertex cover. What classical graph problem does this reduce to?


:[[7.21]]]. Consider the problem of determining whether a given undirected graph &lt;math&gt;G=(V,E)&lt;/math&gt; contains a ''triangle'' or cycle of length 3. 
:(a)Give an  &lt;math&gt;O(|V|^3)&lt;/math&gt; to find a triangle if one exists.
:(b)Improve your algorithm to run in time &lt;math&gt;O(|V| \cdot |E|)&lt;/math&gt;. You may assume &lt;math&gt;|V| \leq |E|&lt;/math&gt;. 
:Observe that these bounds gives you time to convert between the adjacency matrix and adjacency list representations of &lt;math&gt;G&lt;/math&gt;.
[[7.21|Solution]]


:7.22. Consider a set of movies &lt;math&gt;M_1, M_2, \ldots, M_k&lt;/math&gt;. There is a set of customers, each one of which indicates the two movies they would like to see this weekend. Movies are shown on Saturday evening and Sunday evening. Multiple movies may be screened at the same time. 
:You must decide which movies should be televised on Saturday and which on Sunday, so that every customer gets to see the two movies they desire. Is there a schedule where each movie is shown at most once? Design an efficient algorithm to find such a schedule if one exists.


:[[7.23]].The ''diameter'' of a tree &lt;math&gt;T=(V,E)&lt;/math&gt; is given by 
&lt;center&gt;&lt;math&gt;\max_{u,v\in V} \delta(u,v)&lt;/math&gt;&lt;/center&gt;
:(where &lt;math&gt;\delta(u,v)&lt;/math&gt; is the number of edges on the path from &lt;math&gt;u&lt;/math&gt; to &lt;math&gt;v&lt;/math&gt;).  Describe an efficient algorithm to compute the diameter of a tree, and show the correctness and analyze the running time of your algorithm.
[[7.23|Solution]]


:7.24. Given an undirected graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges, and an integer &lt;math&gt;k&lt;/math&gt;, give an &lt;math&gt;O(m+n)&lt;/math&gt; algorithm that finds the maximum induced subgraph &lt;math&gt;H&lt;/math&gt; of &lt;math&gt;G&lt;/math&gt; such that each vertex in &lt;math&gt;H&lt;/math&gt; has degree &lt;math&gt;\geq k&lt;/math&gt;, or prove that no such graph exists. An induced subgraph &lt;math&gt;F=(U,R)&lt;/math&gt; of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of &lt;math&gt;U&lt;/math&gt; of the vertices &lt;math&gt;V&lt;/math&gt; of &lt;math&gt;G&lt;/math&gt;, and all edges &lt;math&gt;R&lt;/math&gt; of &lt;math&gt;G&lt;/math&gt; such that both vertices of each edge are in &lt;math&gt;U&lt;/math&gt;.


:[[7.25]]. Let &lt;math&gt;v&lt;/math&gt; and &lt;math&gt;w&lt;/math&gt; be two vertices in a directed graph &lt;math&gt;G=(V,E &lt;/math&gt;. Design a linear-time algorithm to find the ''number'' of different shortest paths (not necessarily vertex disjoint) between &lt;math&gt;v&lt;/math&gt; and &lt;math&gt;w&lt;/math&gt;. Note: the edges in &lt;math&gt;G&lt;/math&gt; are unweighted.
[[7.25|Solution]]


:7.26. Design a linear-time algorithm to eliminate each vertex &lt;math&gt;v&lt;/math&gt; of degree 2 from a graph by replacing edges &lt;math&gt;(u,v)&lt;/math&gt; and &lt;math&gt;(v,w)&lt;/math&gt; by an edge &lt;math&gt;(u,w)&lt;/math&gt;. We also seek to eliminate multiple copies of edges by replacing them with a single edge. Note that removing multiple copies of an edge may create a new vertex of degree 2, which has to be removed, and that removing a vertex of degree 2 may create multiple edges, which also must be removed.

===Directed Graphs===

:[[7.27]]. The reverse of a directed graph &lt;math&gt;G = (V, E)&lt;/math&gt; is another directed graph &lt;math&gt;G^R = (V, E^R)&lt;/math&gt; on the same vertex set, but with all edges reversed; that is, &lt;math&gt;E^R = {(v, u) : (u, v) \in E}&lt;/math&gt;. Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm for computing the reverse of an &lt;math&gt;n&lt;/math&gt;-vertex &lt;math&gt;m&lt;/math&gt;-edge graph in adjacency list format.
[[7.27|Solution]]


:7.28. Your job is to arrange &lt;math&gt;n&lt;/math&gt; ill-behaved children in a straight line, facing front. You are given a list of &lt;math&gt;m&lt;/math&gt; statements of the form “&lt;math&gt;i&lt;/math&gt; hates &lt;math&gt;j&lt;/math&gt;.” If &lt;math&gt;i&lt;/math&gt; hates &lt;math&gt;j&lt;/math&gt;, then you do not want to put &lt;math&gt;i&lt;/math&gt; somewhere behind &lt;math&gt;j&lt;/math&gt;, because then &lt;math&gt;i&lt;/math&gt; is capable of throwing something at &lt;math&gt;j&lt;/math&gt;.
:(a) Give an algorithm that orders the line (or says that it is not possible) in &lt;math&gt;O(m + n)&lt;/math&gt; time.
:(b) Suppose instead you want to arrange the children in rows such that if &lt;math&gt;i&lt;/math&gt; hates &lt;math&gt;j&lt;/math&gt;, then &lt;math&gt;i&lt;/math&gt; must be in a lower numbered row than &lt;math&gt;j&lt;/math&gt;. Give an efficient algorithm to find the minimum number of rows needed, if it is possible.


:[[7.29]]. A particular academic program has &lt;math&gt;n&lt;/math&gt; required courses, certain pairs of which have prerequisite relations so that &lt;math&gt;(x, y)&lt;/math&gt; means you must take course &lt;math&gt;x&lt;/math&gt; before &lt;math&gt;y&lt;/math&gt;. How would you analyze the prerequisite pairs to make sure it is possible for people to complete the program?
[[7.29|Solution]]


:7.30. Gotcha-solitaire is a game on a deck with &lt;math&gt;n&lt;/math&gt; distinct cards (all face up) and &lt;math&gt;m&lt;/math&gt; gotcha pairs &lt;math&gt;(i, j)&lt;/math&gt; such that card &lt;math&gt;i&lt;/math&gt; must be played sometime before card &lt;math&gt;j&lt;/math&gt;. You play by sequentially choosing cards, and win if you pick up the entire deck without violating any gotcha pair constraints. Give an efficient algorithm to find a winning pickup order if one exists.


:[[7.31]]. You are given a list of &lt;math&gt;n&lt;/math&gt; words each of length &lt;math&gt;k&lt;/math&gt; in a language you don’t know, although you are told that words are sorted in lexicographic (alphabetical) order. Reconstruct the order of the α alphabet letters (characters) in that language. 
:For example, if the strings are &lt;math&gt;{QQZ, QZZ, XQZ, XQX, XXX}&lt;/math&gt;, the character order must be &lt;math&gt;Q&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt; before &lt;math&gt;X&lt;/math&gt;.
:(a) Give an algorithm to efficiently reconstruct this character order. (Hint: use a graph structure, where each node represents one letter.)
:(b) What is its running time, as a function of &lt;math&gt;n, k&lt;/math&gt;, and &lt;math&gt;\alpha&lt;/math&gt;?
[[7.31|Solution]]


:7.32. A ''weakly connected component'' in a directed graph is a connected component ignoring the direction of the edges. Adding a single directed edge to a directed graph can reduce the number of weakly connected components, but by at most how many components? What about the number of strongly connected components?


:[[7.33]]. Design a linear-time algorithm that, given an undirected graph &lt;math&gt;G&lt;/math&gt; and a particular edge &lt;math&gt;e&lt;/math&gt; in it, determines whether &lt;math&gt;G&lt;/math&gt; has a cycle containing &lt;math&gt;e&lt;/math&gt;.
[[7.33|Solution]]


:7.34. An ''arborescence'' of a directed graph &lt;math&gt;G&lt;/math&gt; is a rooted tree such that there is a directed path from the root to every other vertex in the graph. Give an efficient and correct algorithm to test whether &lt;math&gt;G&lt;/math&gt; contains an arborescence, and its time complexity.


:[[7.35]]. A mother vertex in a directed graph &lt;math&gt;G = (V, E)&lt;/math&gt; is a vertex &lt;math&gt;v&lt;/math&gt; such that all other vertices &lt;math&gt;G&lt;/math&gt; can be reached by a directed path from &lt;math&gt;v&lt;/math&gt;. 
:(a) Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm to test whether a given vertex &lt;math&gt;v&lt;/math&gt; is a mother of &lt;math&gt;G&lt;/math&gt;, where &lt;math&gt;n = |V|&lt;/math&gt; and &lt;math&gt;m = |E|&lt;/math&gt;. 
:(b) Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm to test whether graph &lt;math&gt;G&lt;/math&gt; contains a mother vertex.
[[7.35|Solution]]


:7.36. Let &lt;math&gt;G&lt;/math&gt; be a directed graph. We say that &lt;math&gt;G&lt;/math&gt; is ''k-cyclic'' if every (not necessarily simple) cycle in &lt;math&gt;G&lt;/math&gt; contains at most &lt;math&gt;k&lt;/math&gt; distinct nodes. Give a linear-time algorithm to determine if a directed graph &lt;math&gt;G&lt;/math&gt; is &lt;math&gt;k&lt;/math&gt;-cyclic, where &lt;math&gt;G&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt; are given as inputs. Justify the correctness and running time of your algorithm.


:[[7.37]]. A ''tournament'' is a directed graph formed by taking the complete undirected graph and assigning arbitrary directions on the edges—that is, a graph &lt;math&gt;G = (V, E)&lt;/math&gt; such that for all &lt;math&gt;u,v \in V&lt;/math&gt;, exactly one of &lt;math&gt;(u, v)&lt;/math&gt; or &lt;math&gt;(v, u)&lt;/math&gt; is in &lt;math&gt;E&lt;/math&gt;. Show that every tournament has a Hamiltonian path—that is, a path that visits every vertex exactly once. Give an algorithm to find this path.
[[7.37|Solution]]

===Articulation Vertices===

:7.38. An articulation vertex of a connected graph &lt;math&gt;G&lt;math&gt; is a vertex whose deletion disconnects &lt;math&gt;G&lt;/math&gt;. Let &lt;math&gt;G&lt;/math&gt; be a graph with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges. Give a simple &lt;math&gt;O(n+m)&lt;/math&gt; algorithm for finding a vertex of &lt;math&gt;G&lt;/math&gt; that is not an articulation vertex—that is, whose deletion does not disconnect &lt;math&gt;G&lt;/math&gt;.


:[[7.39]]. Following up on the previous problem, give an &lt;math&gt;O(n+m)&lt;/math&gt; algorithm that finds a deletion order for the &lt;math&gt;n&lt;/math&gt; vertices such that no deletion disconnects the graph. (Hint: think DFS/BFS.)
[[7.39|Solution]]


:7.40. Suppose &lt;math&gt;G&lt;/math&gt; is a connected undirected graph. An edge &lt;math&gt;e&lt;/math&gt; whose removal disconnects the graph is called a bridge. Must every bridge &lt;math&gt;e&lt;/math&gt; be an edge in a depth-first search tree of &lt;math&gt;G&lt;/math&gt;? Give a proof or a counterexample.


:[[7.41]]. A city that only has two-way streets has decided to change them all into one-way streets. They want to ensure that the new network is strongly connected so everyone can legally drive anywhere in the city and back.
:(a) Let &lt;math&gt;G&lt;/math&gt; be the original undirected graph. Prove that there is a way to properly orient/direct the edges of &lt;math&gt;G&lt;/math&gt; provided &lt;math&gt;G&lt;/math&gt; does not contain a bridge.
:(b) Give an efficient algorithm to orient the edges of a bridgeless graph &lt;math&gt;G&lt;/math&gt; so the result is strongly connected.
[[7.41|Solution]]

===Interview Problems===

:7.42. Which data structures are used in depth-first and breath-first search?


:[[7.43]]. Write a function to traverse binary search tree and return the ith node in sorted order.
[[7.43|Solution]]


Back to [[Chapter List]]</text>
      <sha1>swbvacez8wajijdf8fqmqkr1oc3puey</sha1>
    </revision>
    <revision>
      <id>247</id>
      <parentid>246</parentid>
      <timestamp>2020-09-14T17:43:14Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Articulation Vertices */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="19153">=Graph Traversal=

===Simulating Graph Algorithms===

:[[7.1]]. For the following graphs &lt;math&gt;G_1&lt;/math&gt; (left) and &lt;math&gt;G_2&lt;/math&gt; (right):
:(see book for figures)

:(a)Report the order of the vertices encountered on a breadth-first search starting from vertex &lt;math&gt;A&lt;/math&gt;. Break all ties by picking the vertices in alphabetical order (i.e., &lt;math&gt;A&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt;).
:(b)Report the order of the vertices encountered on a depth-first search starting from vertex &lt;math&gt;A&lt;/math&gt;. Break all ties by picking the vertices in alphabetical order (i.e., &lt;math&gt;A&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt;).
[[7.1|Solution]]


:7.2. Do a topological sort of the following graph &lt;math&gt;G&lt;/math&gt;:
:(see book for figure)

===Traversal===

:[[7.3]]. Prove that there is a unique path between any pair of vertices in a tree.
[[7.3|Solution]]


:7.4. Prove that in a breadth-first search on a undirected graph &lt;math&gt;G&lt;/math&gt;, every edge is either a tree edge or a cross edge, where &lt;math&gt;x&lt;/math&gt; is neither an ancestor nor descendant of &lt;math&gt;y&lt;/math&gt; in cross edge &lt;math&gt;(x, y)&lt;/math&gt;.


:[[7.5]]. Give a linear algorithm to compute the chromatic number of graphs where each vertex has degree at most 2. Any bipartite graph has a chromatic number of 2. Must such graphs be bipartite?
[[7.5|Solution]]


:7.6. You are given a connected, undirected graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges. Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm to identify an edge you can remove from &lt;math&gt;G&lt;/math&gt; while still leaving &lt;math&gt;G&lt;/math&gt; connected, if one exists. Can you reduce the running time to &lt;math&gt;O(n)&lt;/math&gt;?


:[[7.7]]. In breadth-first and depth-first search, an undiscovered node is marked ''discovered'' when it is first encountered, and marked ''processed'' when it has been completely searched. At any given moment, several nodes might be simultaneously in the ''discovered'' state.
:(a) Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that &lt;math&gt;\Theta(n)&lt;/math&gt; nodes are simultaneously in the ''discovered'' state during a ''breadth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.
:(b) Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that &lt;math&gt;\Theta(n)&lt;/math&gt; nodes are simultaneously in the ''discovered'' state during a ''depth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.
:(c)  Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that at some point &lt;math&gt;\Theta(n)&lt;/math&gt; nodes remain ''undiscovered'', while &lt;math&gt;\Theta(n)&lt;/math&gt; nodes have been ''processed'' during a ''depth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.(Note, there may also be ''discovered'' nodes.)
[[7.7|Solution]]


:7.8. Given pre-order and in-order traversals of a binary tree (discussed in Section 3.4.1), is it possible to reconstruct the tree? If so, sketch an algorithm to do it. If not, give a counterexample. Repeat the problem if you are given the pre-order and post-order traversals.


:[[7.9]]. Present correct and efficient algorithms to convert an undirected graph &lt;math&gt;G&lt;/math&gt; between the following graph data structures. You must give the time complexity of each algorithm, assuming &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges.
:(a)Convert from an adjacency matrix to adjacency lists.
:(b)Convert from an adjacency list to an incidence matrix. An incidence matrix &lt;math&gt;M&lt;/math&gt; has a row for each vertex and a column for each edge, such that &lt;math&gt;M[i,j]=1&lt;/math&gt; if vertex &lt;math&gt;i&lt;/math&gt; is part of edge &lt;math&gt;j&lt;/math&gt;, otherwise &lt;math&gt;M[i,j] = 0&lt;/math&gt;.
:(c)Convert from an incidence matrix to adjacency lists.
[[7.9|Solution]]


:7.10. Suppose an arithmetic expression is given as a tree. Each leaf is an integer and each internal node is one of the standard arithmetical operations &lt;math&gt;(+, -, *, /)&lt;/math&gt;. For example, the expression &lt;math&gt;2+3*4+(3*4)/5&lt;/math&gt; is represented by the tree in Figure 7.17(a). Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for evaluating such an expression, where there are &lt;math&gt;n&lt;/math&gt; nodes in the tree.


:[[7.11]]. Suppose an arithmetic expression is given as a DAG (directed acyclic graph) with common subexpressions removed. Each leaf is an integer and each internal node is one of the standard arithmetical operations &lt;math&gt;(+,-,*,/)&lt;/math&gt;. For example, the expression &lt;math&gt;2+3*4+(3*4)/5&lt;/math&gt; is represented by the DAG in Figure (see book)(b). Give an &lt;math&gt;O(n+m)&lt;/math&gt; algorithm for evaluating such a DAG, where there are &lt;math&gt;n&lt;/math&gt; nodes and &lt;math&gt;m&lt;/math&gt; edges in the DAG. Hint: modify an algorithm for the tree case to achieve the desired efficiency.
[[7.11|Solution]]


:7.12. The war story of Section 7.4 (page 210) describes an algorithm for constructing the dual graph of the triangulation efficiently, although it does not guarantee linear time. Give a worst-case linear algorithm for the problem.

===Applications===

:[[7.13]]. The Chutes and Ladders game has a board with n cells where you seek to travel from cell 1 to cell &lt;math&gt;n&lt;/math&gt;. To move, a player throws a six-sided dice to determine how many cells forward they move. This board also contains chutes and ladders that connect certain pairs of cells. A player who lands on the mouth of a chute immediately falls back down to the cell at the other end. A player who lands on the base of a ladder immediately travels up to the cell at the top of the ladder. Suppose you have rigged the dice to give you full control of the number for each roll. Give an efficient algorithm to find the minimum number of dice throws to win.
[[7.13|Solution]]


:7.14. Plum blossom poles are a Kung Fu training technique, consisting of &lt;math&gt;n&lt;/math&gt; large posts partially sunk into the ground, with each pole &lt;math&gt;p_i&lt;/math&gt; at position &lt;math&gt;(x_i, y_i)&lt;/math&gt;. Students practice martial arts techniques by stepping from the top of one pole to the top of another pole. In order to keep balance, each step must be more than &lt;math&gt;d&lt;/math&gt; meters but less than &lt;math&gt;2d&lt;/math&gt; meters. Give an efficient algorithm to find a safe path from pole &lt;math&gt;p_s&lt;/math&gt; to &lt;math&gt;p_t&lt;/math&gt; if it exists.


:[[7.15]]. You are planning the seating arrangement for a wedding given a list of guests, &lt;math&gt;V&lt;/math&gt;. For each guest &lt;math&gt;g&lt;/math&gt; you have a list of all other guests who are on bad terms with them. Feelings are reciprocal: if &lt;math&gt;h&lt;/math&gt; is on bad terms with &lt;math&gt;g&lt;/math&gt;, then &lt;math&gt;g&lt;/math&gt; is on bad terms with &lt;math&gt;h&lt;/math&gt;. Your goal is to arrange the seating such that no pair of guests sitting at the same table are on bad terms with each other. There will be only two tables at the wedding. Give an efficient algorithm to find an acceptable seating arrangement if one exists.
[[7.15|Solution]]

===Algorithm Design===

:7.16. The ''square'' of a directed graph &lt;math&gt;G=(V,E)&lt;/math&gt; is the graph &lt;math&gt;G^2=(V,E^2)&lt;/math&gt; such that &lt;math&gt;(u,w) \in E^2&lt;/math&gt; iff there exists &lt;math&gt;v \in V&lt;/math&gt; such that &lt;math&gt;(u,v) \in E&lt;/math&gt; and &lt;math&gt;(v,w) \in E&lt;/math&gt;; i.e., there is a path of exactly two edges from &lt;math&gt;u&lt;/math&gt; to &lt;math&gt;w&lt;/math&gt;.
:Give efficient algorithms for both adjacency lists and matrices.


:[[7.17]]. A ''vertex cover'' of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V'&lt;/math&gt; such that each edge in &lt;math&gt;E&lt;/math&gt; is incident on at least one vertex of &lt;math&gt;V'&lt;/math&gt;.
:(a)Give an efficient algorithm to find a minimum-size vertex cover if &lt;math&gt;G&lt;/math&gt; is a tree.
:(b)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree such that the weight of each vertex is equal to the degree of that vertex. Give an efficient algorithm to find a minimum-weight vertex cover of &lt;math&gt;G&lt;/math&gt;.
:(c)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree with arbitrary weights associated with the vertices. Give an efficient algorithm to find a minimum-weight vertex cover of &lt;math&gt;G&lt;/math&gt;.
[[7.17|Solution]]


:7.18. A ''vertex cover'' of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V' \in V&lt;/math&gt; such that every edge in &lt;math&gt;E&lt;/math&gt; contains at least one vertex from &lt;math&gt;V'&lt;/math&gt;. Delete all the leaves from any depth-first search tree of &lt;math&gt;G&lt;/math&gt;. Must the remaining vertices form a vertex cover of &lt;math&gt;G&lt;/math&gt;? Give a proof or a counterexample.


:[[7.19]]. An ''independent set'' of an undirected graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a set of vertices $U$ such that no edge in &lt;math&gt;E&lt;/math&gt; is incident on two vertices of &lt;math&gt;U&lt;/math&gt;.
:(a)Give an efficient algorithm to find a maximum-size independent set if &lt;math&gt;G&lt;/math&gt; is a tree.
:(b)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree with weights associated with the vertices such that the weight of each vertex is equal to the degree of that vertex. Give an efficient algorithm to find a maximum independent set of &lt;math&gt;G&lt;/math&gt;.
:(c)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree with arbitrary weights associated with the vertices. Give an efficient algorithm to find a maximum independent set of &lt;math&gt;G&lt;/math&gt;.
[[7.19|Solution]]


:7.20. A ''vertex cover'' of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V' \in V&lt;/math&gt; such that every edge in &lt;math&gt;E&lt;/math&gt; contains ''at least one'' vertex from &lt;math&gt;V'&lt;/math&gt;. An ''independent set'' of graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V' \in V&lt;/math&gt; such that no edge in &lt;math&gt;E&lt;/math&gt; contains both vertices from &lt;math&gt;V'&lt;/math&gt;.
:An ''independent vertex cover'' is a subset of vertices that is both an independent set and a vertex cover of &lt;math&gt;G&lt;/math&gt;. Give an efficient algorithm for testing whether &lt;math&gt;G&lt;/math&gt; contains an independent vertex cover. What classical graph problem does this reduce to?


:[[7.21]]]. Consider the problem of determining whether a given undirected graph &lt;math&gt;G=(V,E)&lt;/math&gt; contains a ''triangle'' or cycle of length 3. 
:(a)Give an  &lt;math&gt;O(|V|^3)&lt;/math&gt; to find a triangle if one exists.
:(b)Improve your algorithm to run in time &lt;math&gt;O(|V| \cdot |E|)&lt;/math&gt;. You may assume &lt;math&gt;|V| \leq |E|&lt;/math&gt;. 
:Observe that these bounds gives you time to convert between the adjacency matrix and adjacency list representations of &lt;math&gt;G&lt;/math&gt;.
[[7.21|Solution]]


:7.22. Consider a set of movies &lt;math&gt;M_1, M_2, \ldots, M_k&lt;/math&gt;. There is a set of customers, each one of which indicates the two movies they would like to see this weekend. Movies are shown on Saturday evening and Sunday evening. Multiple movies may be screened at the same time. 
:You must decide which movies should be televised on Saturday and which on Sunday, so that every customer gets to see the two movies they desire. Is there a schedule where each movie is shown at most once? Design an efficient algorithm to find such a schedule if one exists.


:[[7.23]].The ''diameter'' of a tree &lt;math&gt;T=(V,E)&lt;/math&gt; is given by 
&lt;center&gt;&lt;math&gt;\max_{u,v\in V} \delta(u,v)&lt;/math&gt;&lt;/center&gt;
:(where &lt;math&gt;\delta(u,v)&lt;/math&gt; is the number of edges on the path from &lt;math&gt;u&lt;/math&gt; to &lt;math&gt;v&lt;/math&gt;).  Describe an efficient algorithm to compute the diameter of a tree, and show the correctness and analyze the running time of your algorithm.
[[7.23|Solution]]


:7.24. Given an undirected graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges, and an integer &lt;math&gt;k&lt;/math&gt;, give an &lt;math&gt;O(m+n)&lt;/math&gt; algorithm that finds the maximum induced subgraph &lt;math&gt;H&lt;/math&gt; of &lt;math&gt;G&lt;/math&gt; such that each vertex in &lt;math&gt;H&lt;/math&gt; has degree &lt;math&gt;\geq k&lt;/math&gt;, or prove that no such graph exists. An induced subgraph &lt;math&gt;F=(U,R)&lt;/math&gt; of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of &lt;math&gt;U&lt;/math&gt; of the vertices &lt;math&gt;V&lt;/math&gt; of &lt;math&gt;G&lt;/math&gt;, and all edges &lt;math&gt;R&lt;/math&gt; of &lt;math&gt;G&lt;/math&gt; such that both vertices of each edge are in &lt;math&gt;U&lt;/math&gt;.


:[[7.25]]. Let &lt;math&gt;v&lt;/math&gt; and &lt;math&gt;w&lt;/math&gt; be two vertices in a directed graph &lt;math&gt;G=(V,E &lt;/math&gt;. Design a linear-time algorithm to find the ''number'' of different shortest paths (not necessarily vertex disjoint) between &lt;math&gt;v&lt;/math&gt; and &lt;math&gt;w&lt;/math&gt;. Note: the edges in &lt;math&gt;G&lt;/math&gt; are unweighted.
[[7.25|Solution]]


:7.26. Design a linear-time algorithm to eliminate each vertex &lt;math&gt;v&lt;/math&gt; of degree 2 from a graph by replacing edges &lt;math&gt;(u,v)&lt;/math&gt; and &lt;math&gt;(v,w)&lt;/math&gt; by an edge &lt;math&gt;(u,w)&lt;/math&gt;. We also seek to eliminate multiple copies of edges by replacing them with a single edge. Note that removing multiple copies of an edge may create a new vertex of degree 2, which has to be removed, and that removing a vertex of degree 2 may create multiple edges, which also must be removed.

===Directed Graphs===

:[[7.27]]. The reverse of a directed graph &lt;math&gt;G = (V, E)&lt;/math&gt; is another directed graph &lt;math&gt;G^R = (V, E^R)&lt;/math&gt; on the same vertex set, but with all edges reversed; that is, &lt;math&gt;E^R = {(v, u) : (u, v) \in E}&lt;/math&gt;. Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm for computing the reverse of an &lt;math&gt;n&lt;/math&gt;-vertex &lt;math&gt;m&lt;/math&gt;-edge graph in adjacency list format.
[[7.27|Solution]]


:7.28. Your job is to arrange &lt;math&gt;n&lt;/math&gt; ill-behaved children in a straight line, facing front. You are given a list of &lt;math&gt;m&lt;/math&gt; statements of the form “&lt;math&gt;i&lt;/math&gt; hates &lt;math&gt;j&lt;/math&gt;.” If &lt;math&gt;i&lt;/math&gt; hates &lt;math&gt;j&lt;/math&gt;, then you do not want to put &lt;math&gt;i&lt;/math&gt; somewhere behind &lt;math&gt;j&lt;/math&gt;, because then &lt;math&gt;i&lt;/math&gt; is capable of throwing something at &lt;math&gt;j&lt;/math&gt;.
:(a) Give an algorithm that orders the line (or says that it is not possible) in &lt;math&gt;O(m + n)&lt;/math&gt; time.
:(b) Suppose instead you want to arrange the children in rows such that if &lt;math&gt;i&lt;/math&gt; hates &lt;math&gt;j&lt;/math&gt;, then &lt;math&gt;i&lt;/math&gt; must be in a lower numbered row than &lt;math&gt;j&lt;/math&gt;. Give an efficient algorithm to find the minimum number of rows needed, if it is possible.


:[[7.29]]. A particular academic program has &lt;math&gt;n&lt;/math&gt; required courses, certain pairs of which have prerequisite relations so that &lt;math&gt;(x, y)&lt;/math&gt; means you must take course &lt;math&gt;x&lt;/math&gt; before &lt;math&gt;y&lt;/math&gt;. How would you analyze the prerequisite pairs to make sure it is possible for people to complete the program?
[[7.29|Solution]]


:7.30. Gotcha-solitaire is a game on a deck with &lt;math&gt;n&lt;/math&gt; distinct cards (all face up) and &lt;math&gt;m&lt;/math&gt; gotcha pairs &lt;math&gt;(i, j)&lt;/math&gt; such that card &lt;math&gt;i&lt;/math&gt; must be played sometime before card &lt;math&gt;j&lt;/math&gt;. You play by sequentially choosing cards, and win if you pick up the entire deck without violating any gotcha pair constraints. Give an efficient algorithm to find a winning pickup order if one exists.


:[[7.31]]. You are given a list of &lt;math&gt;n&lt;/math&gt; words each of length &lt;math&gt;k&lt;/math&gt; in a language you don’t know, although you are told that words are sorted in lexicographic (alphabetical) order. Reconstruct the order of the α alphabet letters (characters) in that language. 
:For example, if the strings are &lt;math&gt;{QQZ, QZZ, XQZ, XQX, XXX}&lt;/math&gt;, the character order must be &lt;math&gt;Q&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt; before &lt;math&gt;X&lt;/math&gt;.
:(a) Give an algorithm to efficiently reconstruct this character order. (Hint: use a graph structure, where each node represents one letter.)
:(b) What is its running time, as a function of &lt;math&gt;n, k&lt;/math&gt;, and &lt;math&gt;\alpha&lt;/math&gt;?
[[7.31|Solution]]


:7.32. A ''weakly connected component'' in a directed graph is a connected component ignoring the direction of the edges. Adding a single directed edge to a directed graph can reduce the number of weakly connected components, but by at most how many components? What about the number of strongly connected components?


:[[7.33]]. Design a linear-time algorithm that, given an undirected graph &lt;math&gt;G&lt;/math&gt; and a particular edge &lt;math&gt;e&lt;/math&gt; in it, determines whether &lt;math&gt;G&lt;/math&gt; has a cycle containing &lt;math&gt;e&lt;/math&gt;.
[[7.33|Solution]]


:7.34. An ''arborescence'' of a directed graph &lt;math&gt;G&lt;/math&gt; is a rooted tree such that there is a directed path from the root to every other vertex in the graph. Give an efficient and correct algorithm to test whether &lt;math&gt;G&lt;/math&gt; contains an arborescence, and its time complexity.


:[[7.35]]. A mother vertex in a directed graph &lt;math&gt;G = (V, E)&lt;/math&gt; is a vertex &lt;math&gt;v&lt;/math&gt; such that all other vertices &lt;math&gt;G&lt;/math&gt; can be reached by a directed path from &lt;math&gt;v&lt;/math&gt;. 
:(a) Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm to test whether a given vertex &lt;math&gt;v&lt;/math&gt; is a mother of &lt;math&gt;G&lt;/math&gt;, where &lt;math&gt;n = |V|&lt;/math&gt; and &lt;math&gt;m = |E|&lt;/math&gt;. 
:(b) Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm to test whether graph &lt;math&gt;G&lt;/math&gt; contains a mother vertex.
[[7.35|Solution]]


:7.36. Let &lt;math&gt;G&lt;/math&gt; be a directed graph. We say that &lt;math&gt;G&lt;/math&gt; is ''k-cyclic'' if every (not necessarily simple) cycle in &lt;math&gt;G&lt;/math&gt; contains at most &lt;math&gt;k&lt;/math&gt; distinct nodes. Give a linear-time algorithm to determine if a directed graph &lt;math&gt;G&lt;/math&gt; is &lt;math&gt;k&lt;/math&gt;-cyclic, where &lt;math&gt;G&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt; are given as inputs. Justify the correctness and running time of your algorithm.


:[[7.37]]. A ''tournament'' is a directed graph formed by taking the complete undirected graph and assigning arbitrary directions on the edges—that is, a graph &lt;math&gt;G = (V, E)&lt;/math&gt; such that for all &lt;math&gt;u,v \in V&lt;/math&gt;, exactly one of &lt;math&gt;(u, v)&lt;/math&gt; or &lt;math&gt;(v, u)&lt;/math&gt; is in &lt;math&gt;E&lt;/math&gt;. Show that every tournament has a Hamiltonian path—that is, a path that visits every vertex exactly once. Give an algorithm to find this path.
[[7.37|Solution]]

===Articulation Vertices===

:7.38. An articulation vertex of a connected graph &lt;math&gt;G&lt;/math&gt; is a vertex whose deletion disconnects &lt;math&gt;G&lt;/math&gt;. Let &lt;math&gt;G&lt;/math&gt; be a graph with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges. Give a simple &lt;math&gt;O(n+m)&lt;/math&gt; algorithm for finding a vertex of &lt;math&gt;G&lt;/math&gt; that is not an articulation vertex—that is, whose deletion does not disconnect &lt;math&gt;G&lt;/math&gt;.


:[[7.39]]. Following up on the previous problem, give an &lt;math&gt;O(n+m)&lt;/math&gt; algorithm that finds a deletion order for the &lt;math&gt;n&lt;/math&gt; vertices such that no deletion disconnects the graph. (Hint: think DFS/BFS.)
[[7.39|Solution]]


:7.40. Suppose &lt;math&gt;G&lt;/math&gt; is a connected undirected graph. An edge &lt;math&gt;e&lt;/math&gt; whose removal disconnects the graph is called a bridge. Must every bridge &lt;math&gt;e&lt;/math&gt; be an edge in a depth-first search tree of &lt;math&gt;G&lt;/math&gt;? Give a proof or a counterexample.


:[[7.41]]. A city that only has two-way streets has decided to change them all into one-way streets. They want to ensure that the new network is strongly connected so everyone can legally drive anywhere in the city and back.
:(a) Let &lt;math&gt;G&lt;/math&gt; be the original undirected graph. Prove that there is a way to properly orient/direct the edges of &lt;math&gt;G&lt;/math&gt; provided &lt;math&gt;G&lt;/math&gt; does not contain a bridge.
:(b) Give an efficient algorithm to orient the edges of a bridgeless graph &lt;math&gt;G&lt;/math&gt; so the result is strongly connected.
[[7.41|Solution]]

===Interview Problems===

:7.42. Which data structures are used in depth-first and breath-first search?


:[[7.43]]. Write a function to traverse binary search tree and return the ith node in sorted order.
[[7.43|Solution]]


Back to [[Chapter List]]</text>
      <sha1>mybfaxtq3dplutgtb2520sjjadbohtg</sha1>
    </revision>
    <revision>
      <id>358</id>
      <parentid>247</parentid>
      <timestamp>2020-09-21T01:06:06Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Algorithm Design */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="19152">=Graph Traversal=

===Simulating Graph Algorithms===

:[[7.1]]. For the following graphs &lt;math&gt;G_1&lt;/math&gt; (left) and &lt;math&gt;G_2&lt;/math&gt; (right):
:(see book for figures)

:(a)Report the order of the vertices encountered on a breadth-first search starting from vertex &lt;math&gt;A&lt;/math&gt;. Break all ties by picking the vertices in alphabetical order (i.e., &lt;math&gt;A&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt;).
:(b)Report the order of the vertices encountered on a depth-first search starting from vertex &lt;math&gt;A&lt;/math&gt;. Break all ties by picking the vertices in alphabetical order (i.e., &lt;math&gt;A&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt;).
[[7.1|Solution]]


:7.2. Do a topological sort of the following graph &lt;math&gt;G&lt;/math&gt;:
:(see book for figure)

===Traversal===

:[[7.3]]. Prove that there is a unique path between any pair of vertices in a tree.
[[7.3|Solution]]


:7.4. Prove that in a breadth-first search on a undirected graph &lt;math&gt;G&lt;/math&gt;, every edge is either a tree edge or a cross edge, where &lt;math&gt;x&lt;/math&gt; is neither an ancestor nor descendant of &lt;math&gt;y&lt;/math&gt; in cross edge &lt;math&gt;(x, y)&lt;/math&gt;.


:[[7.5]]. Give a linear algorithm to compute the chromatic number of graphs where each vertex has degree at most 2. Any bipartite graph has a chromatic number of 2. Must such graphs be bipartite?
[[7.5|Solution]]


:7.6. You are given a connected, undirected graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges. Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm to identify an edge you can remove from &lt;math&gt;G&lt;/math&gt; while still leaving &lt;math&gt;G&lt;/math&gt; connected, if one exists. Can you reduce the running time to &lt;math&gt;O(n)&lt;/math&gt;?


:[[7.7]]. In breadth-first and depth-first search, an undiscovered node is marked ''discovered'' when it is first encountered, and marked ''processed'' when it has been completely searched. At any given moment, several nodes might be simultaneously in the ''discovered'' state.
:(a) Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that &lt;math&gt;\Theta(n)&lt;/math&gt; nodes are simultaneously in the ''discovered'' state during a ''breadth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.
:(b) Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that &lt;math&gt;\Theta(n)&lt;/math&gt; nodes are simultaneously in the ''discovered'' state during a ''depth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.
:(c)  Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that at some point &lt;math&gt;\Theta(n)&lt;/math&gt; nodes remain ''undiscovered'', while &lt;math&gt;\Theta(n)&lt;/math&gt; nodes have been ''processed'' during a ''depth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.(Note, there may also be ''discovered'' nodes.)
[[7.7|Solution]]


:7.8. Given pre-order and in-order traversals of a binary tree (discussed in Section 3.4.1), is it possible to reconstruct the tree? If so, sketch an algorithm to do it. If not, give a counterexample. Repeat the problem if you are given the pre-order and post-order traversals.


:[[7.9]]. Present correct and efficient algorithms to convert an undirected graph &lt;math&gt;G&lt;/math&gt; between the following graph data structures. You must give the time complexity of each algorithm, assuming &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges.
:(a)Convert from an adjacency matrix to adjacency lists.
:(b)Convert from an adjacency list to an incidence matrix. An incidence matrix &lt;math&gt;M&lt;/math&gt; has a row for each vertex and a column for each edge, such that &lt;math&gt;M[i,j]=1&lt;/math&gt; if vertex &lt;math&gt;i&lt;/math&gt; is part of edge &lt;math&gt;j&lt;/math&gt;, otherwise &lt;math&gt;M[i,j] = 0&lt;/math&gt;.
:(c)Convert from an incidence matrix to adjacency lists.
[[7.9|Solution]]


:7.10. Suppose an arithmetic expression is given as a tree. Each leaf is an integer and each internal node is one of the standard arithmetical operations &lt;math&gt;(+, -, *, /)&lt;/math&gt;. For example, the expression &lt;math&gt;2+3*4+(3*4)/5&lt;/math&gt; is represented by the tree in Figure 7.17(a). Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for evaluating such an expression, where there are &lt;math&gt;n&lt;/math&gt; nodes in the tree.


:[[7.11]]. Suppose an arithmetic expression is given as a DAG (directed acyclic graph) with common subexpressions removed. Each leaf is an integer and each internal node is one of the standard arithmetical operations &lt;math&gt;(+,-,*,/)&lt;/math&gt;. For example, the expression &lt;math&gt;2+3*4+(3*4)/5&lt;/math&gt; is represented by the DAG in Figure (see book)(b). Give an &lt;math&gt;O(n+m)&lt;/math&gt; algorithm for evaluating such a DAG, where there are &lt;math&gt;n&lt;/math&gt; nodes and &lt;math&gt;m&lt;/math&gt; edges in the DAG. Hint: modify an algorithm for the tree case to achieve the desired efficiency.
[[7.11|Solution]]


:7.12. The war story of Section 7.4 (page 210) describes an algorithm for constructing the dual graph of the triangulation efficiently, although it does not guarantee linear time. Give a worst-case linear algorithm for the problem.

===Applications===

:[[7.13]]. The Chutes and Ladders game has a board with n cells where you seek to travel from cell 1 to cell &lt;math&gt;n&lt;/math&gt;. To move, a player throws a six-sided dice to determine how many cells forward they move. This board also contains chutes and ladders that connect certain pairs of cells. A player who lands on the mouth of a chute immediately falls back down to the cell at the other end. A player who lands on the base of a ladder immediately travels up to the cell at the top of the ladder. Suppose you have rigged the dice to give you full control of the number for each roll. Give an efficient algorithm to find the minimum number of dice throws to win.
[[7.13|Solution]]


:7.14. Plum blossom poles are a Kung Fu training technique, consisting of &lt;math&gt;n&lt;/math&gt; large posts partially sunk into the ground, with each pole &lt;math&gt;p_i&lt;/math&gt; at position &lt;math&gt;(x_i, y_i)&lt;/math&gt;. Students practice martial arts techniques by stepping from the top of one pole to the top of another pole. In order to keep balance, each step must be more than &lt;math&gt;d&lt;/math&gt; meters but less than &lt;math&gt;2d&lt;/math&gt; meters. Give an efficient algorithm to find a safe path from pole &lt;math&gt;p_s&lt;/math&gt; to &lt;math&gt;p_t&lt;/math&gt; if it exists.


:[[7.15]]. You are planning the seating arrangement for a wedding given a list of guests, &lt;math&gt;V&lt;/math&gt;. For each guest &lt;math&gt;g&lt;/math&gt; you have a list of all other guests who are on bad terms with them. Feelings are reciprocal: if &lt;math&gt;h&lt;/math&gt; is on bad terms with &lt;math&gt;g&lt;/math&gt;, then &lt;math&gt;g&lt;/math&gt; is on bad terms with &lt;math&gt;h&lt;/math&gt;. Your goal is to arrange the seating such that no pair of guests sitting at the same table are on bad terms with each other. There will be only two tables at the wedding. Give an efficient algorithm to find an acceptable seating arrangement if one exists.
[[7.15|Solution]]

===Algorithm Design===

:7.16. The ''square'' of a directed graph &lt;math&gt;G=(V,E)&lt;/math&gt; is the graph &lt;math&gt;G^2=(V,E^2)&lt;/math&gt; such that &lt;math&gt;(u,w) \in E^2&lt;/math&gt; iff there exists &lt;math&gt;v \in V&lt;/math&gt; such that &lt;math&gt;(u,v) \in E&lt;/math&gt; and &lt;math&gt;(v,w) \in E&lt;/math&gt;; i.e., there is a path of exactly two edges from &lt;math&gt;u&lt;/math&gt; to &lt;math&gt;w&lt;/math&gt;.
:Give efficient algorithms for both adjacency lists and matrices.


:[[7.17]]. A ''vertex cover'' of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V'&lt;/math&gt; such that each edge in &lt;math&gt;E&lt;/math&gt; is incident on at least one vertex of &lt;math&gt;V'&lt;/math&gt;.
:(a)Give an efficient algorithm to find a minimum-size vertex cover if &lt;math&gt;G&lt;/math&gt; is a tree.
:(b)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree such that the weight of each vertex is equal to the degree of that vertex. Give an efficient algorithm to find a minimum-weight vertex cover of &lt;math&gt;G&lt;/math&gt;.
:(c)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree with arbitrary weights associated with the vertices. Give an efficient algorithm to find a minimum-weight vertex cover of &lt;math&gt;G&lt;/math&gt;.
[[7.17|Solution]]


:7.18. A ''vertex cover'' of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V' \in V&lt;/math&gt; such that every edge in &lt;math&gt;E&lt;/math&gt; contains at least one vertex from &lt;math&gt;V'&lt;/math&gt;. Delete all the leaves from any depth-first search tree of &lt;math&gt;G&lt;/math&gt;. Must the remaining vertices form a vertex cover of &lt;math&gt;G&lt;/math&gt;? Give a proof or a counterexample.


:[[7.19]]. An ''independent set'' of an undirected graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a set of vertices $U$ such that no edge in &lt;math&gt;E&lt;/math&gt; is incident on two vertices of &lt;math&gt;U&lt;/math&gt;.
:(a)Give an efficient algorithm to find a maximum-size independent set if &lt;math&gt;G&lt;/math&gt; is a tree.
:(b)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree with weights associated with the vertices such that the weight of each vertex is equal to the degree of that vertex. Give an efficient algorithm to find a maximum independent set of &lt;math&gt;G&lt;/math&gt;.
:(c)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree with arbitrary weights associated with the vertices. Give an efficient algorithm to find a maximum independent set of &lt;math&gt;G&lt;/math&gt;.
[[7.19|Solution]]


:7.20. A ''vertex cover'' of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V' \in V&lt;/math&gt; such that every edge in &lt;math&gt;E&lt;/math&gt; contains ''at least one'' vertex from &lt;math&gt;V'&lt;/math&gt;. An ''independent set'' of graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V' \in V&lt;/math&gt; such that no edge in &lt;math&gt;E&lt;/math&gt; contains both vertices from &lt;math&gt;V'&lt;/math&gt;.
:An ''independent vertex cover'' is a subset of vertices that is both an independent set and a vertex cover of &lt;math&gt;G&lt;/math&gt;. Give an efficient algorithm for testing whether &lt;math&gt;G&lt;/math&gt; contains an independent vertex cover. What classical graph problem does this reduce to?


:[[7.21]]. Consider the problem of determining whether a given undirected graph &lt;math&gt;G=(V,E)&lt;/math&gt; contains a ''triangle'' or cycle of length 3. 
:(a)Give an  &lt;math&gt;O(|V|^3)&lt;/math&gt; to find a triangle if one exists.
:(b)Improve your algorithm to run in time &lt;math&gt;O(|V| \cdot |E|)&lt;/math&gt;. You may assume &lt;math&gt;|V| \leq |E|&lt;/math&gt;. 
:Observe that these bounds gives you time to convert between the adjacency matrix and adjacency list representations of &lt;math&gt;G&lt;/math&gt;.
[[7.21|Solution]]


:7.22. Consider a set of movies &lt;math&gt;M_1, M_2, \ldots, M_k&lt;/math&gt;. There is a set of customers, each one of which indicates the two movies they would like to see this weekend. Movies are shown on Saturday evening and Sunday evening. Multiple movies may be screened at the same time. 
:You must decide which movies should be televised on Saturday and which on Sunday, so that every customer gets to see the two movies they desire. Is there a schedule where each movie is shown at most once? Design an efficient algorithm to find such a schedule if one exists.


:[[7.23]].The ''diameter'' of a tree &lt;math&gt;T=(V,E)&lt;/math&gt; is given by 
&lt;center&gt;&lt;math&gt;\max_{u,v\in V} \delta(u,v)&lt;/math&gt;&lt;/center&gt;
:(where &lt;math&gt;\delta(u,v)&lt;/math&gt; is the number of edges on the path from &lt;math&gt;u&lt;/math&gt; to &lt;math&gt;v&lt;/math&gt;).  Describe an efficient algorithm to compute the diameter of a tree, and show the correctness and analyze the running time of your algorithm.
[[7.23|Solution]]


:7.24. Given an undirected graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges, and an integer &lt;math&gt;k&lt;/math&gt;, give an &lt;math&gt;O(m+n)&lt;/math&gt; algorithm that finds the maximum induced subgraph &lt;math&gt;H&lt;/math&gt; of &lt;math&gt;G&lt;/math&gt; such that each vertex in &lt;math&gt;H&lt;/math&gt; has degree &lt;math&gt;\geq k&lt;/math&gt;, or prove that no such graph exists. An induced subgraph &lt;math&gt;F=(U,R)&lt;/math&gt; of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of &lt;math&gt;U&lt;/math&gt; of the vertices &lt;math&gt;V&lt;/math&gt; of &lt;math&gt;G&lt;/math&gt;, and all edges &lt;math&gt;R&lt;/math&gt; of &lt;math&gt;G&lt;/math&gt; such that both vertices of each edge are in &lt;math&gt;U&lt;/math&gt;.


:[[7.25]]. Let &lt;math&gt;v&lt;/math&gt; and &lt;math&gt;w&lt;/math&gt; be two vertices in a directed graph &lt;math&gt;G=(V,E &lt;/math&gt;. Design a linear-time algorithm to find the ''number'' of different shortest paths (not necessarily vertex disjoint) between &lt;math&gt;v&lt;/math&gt; and &lt;math&gt;w&lt;/math&gt;. Note: the edges in &lt;math&gt;G&lt;/math&gt; are unweighted.
[[7.25|Solution]]


:7.26. Design a linear-time algorithm to eliminate each vertex &lt;math&gt;v&lt;/math&gt; of degree 2 from a graph by replacing edges &lt;math&gt;(u,v)&lt;/math&gt; and &lt;math&gt;(v,w)&lt;/math&gt; by an edge &lt;math&gt;(u,w)&lt;/math&gt;. We also seek to eliminate multiple copies of edges by replacing them with a single edge. Note that removing multiple copies of an edge may create a new vertex of degree 2, which has to be removed, and that removing a vertex of degree 2 may create multiple edges, which also must be removed.

===Directed Graphs===

:[[7.27]]. The reverse of a directed graph &lt;math&gt;G = (V, E)&lt;/math&gt; is another directed graph &lt;math&gt;G^R = (V, E^R)&lt;/math&gt; on the same vertex set, but with all edges reversed; that is, &lt;math&gt;E^R = {(v, u) : (u, v) \in E}&lt;/math&gt;. Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm for computing the reverse of an &lt;math&gt;n&lt;/math&gt;-vertex &lt;math&gt;m&lt;/math&gt;-edge graph in adjacency list format.
[[7.27|Solution]]


:7.28. Your job is to arrange &lt;math&gt;n&lt;/math&gt; ill-behaved children in a straight line, facing front. You are given a list of &lt;math&gt;m&lt;/math&gt; statements of the form “&lt;math&gt;i&lt;/math&gt; hates &lt;math&gt;j&lt;/math&gt;.” If &lt;math&gt;i&lt;/math&gt; hates &lt;math&gt;j&lt;/math&gt;, then you do not want to put &lt;math&gt;i&lt;/math&gt; somewhere behind &lt;math&gt;j&lt;/math&gt;, because then &lt;math&gt;i&lt;/math&gt; is capable of throwing something at &lt;math&gt;j&lt;/math&gt;.
:(a) Give an algorithm that orders the line (or says that it is not possible) in &lt;math&gt;O(m + n)&lt;/math&gt; time.
:(b) Suppose instead you want to arrange the children in rows such that if &lt;math&gt;i&lt;/math&gt; hates &lt;math&gt;j&lt;/math&gt;, then &lt;math&gt;i&lt;/math&gt; must be in a lower numbered row than &lt;math&gt;j&lt;/math&gt;. Give an efficient algorithm to find the minimum number of rows needed, if it is possible.


:[[7.29]]. A particular academic program has &lt;math&gt;n&lt;/math&gt; required courses, certain pairs of which have prerequisite relations so that &lt;math&gt;(x, y)&lt;/math&gt; means you must take course &lt;math&gt;x&lt;/math&gt; before &lt;math&gt;y&lt;/math&gt;. How would you analyze the prerequisite pairs to make sure it is possible for people to complete the program?
[[7.29|Solution]]


:7.30. Gotcha-solitaire is a game on a deck with &lt;math&gt;n&lt;/math&gt; distinct cards (all face up) and &lt;math&gt;m&lt;/math&gt; gotcha pairs &lt;math&gt;(i, j)&lt;/math&gt; such that card &lt;math&gt;i&lt;/math&gt; must be played sometime before card &lt;math&gt;j&lt;/math&gt;. You play by sequentially choosing cards, and win if you pick up the entire deck without violating any gotcha pair constraints. Give an efficient algorithm to find a winning pickup order if one exists.


:[[7.31]]. You are given a list of &lt;math&gt;n&lt;/math&gt; words each of length &lt;math&gt;k&lt;/math&gt; in a language you don’t know, although you are told that words are sorted in lexicographic (alphabetical) order. Reconstruct the order of the α alphabet letters (characters) in that language. 
:For example, if the strings are &lt;math&gt;{QQZ, QZZ, XQZ, XQX, XXX}&lt;/math&gt;, the character order must be &lt;math&gt;Q&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt; before &lt;math&gt;X&lt;/math&gt;.
:(a) Give an algorithm to efficiently reconstruct this character order. (Hint: use a graph structure, where each node represents one letter.)
:(b) What is its running time, as a function of &lt;math&gt;n, k&lt;/math&gt;, and &lt;math&gt;\alpha&lt;/math&gt;?
[[7.31|Solution]]


:7.32. A ''weakly connected component'' in a directed graph is a connected component ignoring the direction of the edges. Adding a single directed edge to a directed graph can reduce the number of weakly connected components, but by at most how many components? What about the number of strongly connected components?


:[[7.33]]. Design a linear-time algorithm that, given an undirected graph &lt;math&gt;G&lt;/math&gt; and a particular edge &lt;math&gt;e&lt;/math&gt; in it, determines whether &lt;math&gt;G&lt;/math&gt; has a cycle containing &lt;math&gt;e&lt;/math&gt;.
[[7.33|Solution]]


:7.34. An ''arborescence'' of a directed graph &lt;math&gt;G&lt;/math&gt; is a rooted tree such that there is a directed path from the root to every other vertex in the graph. Give an efficient and correct algorithm to test whether &lt;math&gt;G&lt;/math&gt; contains an arborescence, and its time complexity.


:[[7.35]]. A mother vertex in a directed graph &lt;math&gt;G = (V, E)&lt;/math&gt; is a vertex &lt;math&gt;v&lt;/math&gt; such that all other vertices &lt;math&gt;G&lt;/math&gt; can be reached by a directed path from &lt;math&gt;v&lt;/math&gt;. 
:(a) Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm to test whether a given vertex &lt;math&gt;v&lt;/math&gt; is a mother of &lt;math&gt;G&lt;/math&gt;, where &lt;math&gt;n = |V|&lt;/math&gt; and &lt;math&gt;m = |E|&lt;/math&gt;. 
:(b) Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm to test whether graph &lt;math&gt;G&lt;/math&gt; contains a mother vertex.
[[7.35|Solution]]


:7.36. Let &lt;math&gt;G&lt;/math&gt; be a directed graph. We say that &lt;math&gt;G&lt;/math&gt; is ''k-cyclic'' if every (not necessarily simple) cycle in &lt;math&gt;G&lt;/math&gt; contains at most &lt;math&gt;k&lt;/math&gt; distinct nodes. Give a linear-time algorithm to determine if a directed graph &lt;math&gt;G&lt;/math&gt; is &lt;math&gt;k&lt;/math&gt;-cyclic, where &lt;math&gt;G&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt; are given as inputs. Justify the correctness and running time of your algorithm.


:[[7.37]]. A ''tournament'' is a directed graph formed by taking the complete undirected graph and assigning arbitrary directions on the edges—that is, a graph &lt;math&gt;G = (V, E)&lt;/math&gt; such that for all &lt;math&gt;u,v \in V&lt;/math&gt;, exactly one of &lt;math&gt;(u, v)&lt;/math&gt; or &lt;math&gt;(v, u)&lt;/math&gt; is in &lt;math&gt;E&lt;/math&gt;. Show that every tournament has a Hamiltonian path—that is, a path that visits every vertex exactly once. Give an algorithm to find this path.
[[7.37|Solution]]

===Articulation Vertices===

:7.38. An articulation vertex of a connected graph &lt;math&gt;G&lt;/math&gt; is a vertex whose deletion disconnects &lt;math&gt;G&lt;/math&gt;. Let &lt;math&gt;G&lt;/math&gt; be a graph with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges. Give a simple &lt;math&gt;O(n+m)&lt;/math&gt; algorithm for finding a vertex of &lt;math&gt;G&lt;/math&gt; that is not an articulation vertex—that is, whose deletion does not disconnect &lt;math&gt;G&lt;/math&gt;.


:[[7.39]]. Following up on the previous problem, give an &lt;math&gt;O(n+m)&lt;/math&gt; algorithm that finds a deletion order for the &lt;math&gt;n&lt;/math&gt; vertices such that no deletion disconnects the graph. (Hint: think DFS/BFS.)
[[7.39|Solution]]


:7.40. Suppose &lt;math&gt;G&lt;/math&gt; is a connected undirected graph. An edge &lt;math&gt;e&lt;/math&gt; whose removal disconnects the graph is called a bridge. Must every bridge &lt;math&gt;e&lt;/math&gt; be an edge in a depth-first search tree of &lt;math&gt;G&lt;/math&gt;? Give a proof or a counterexample.


:[[7.41]]. A city that only has two-way streets has decided to change them all into one-way streets. They want to ensure that the new network is strongly connected so everyone can legally drive anywhere in the city and back.
:(a) Let &lt;math&gt;G&lt;/math&gt; be the original undirected graph. Prove that there is a way to properly orient/direct the edges of &lt;math&gt;G&lt;/math&gt; provided &lt;math&gt;G&lt;/math&gt; does not contain a bridge.
:(b) Give an efficient algorithm to orient the edges of a bridgeless graph &lt;math&gt;G&lt;/math&gt; so the result is strongly connected.
[[7.41|Solution]]

===Interview Problems===

:7.42. Which data structures are used in depth-first and breath-first search?


:[[7.43]]. Write a function to traverse binary search tree and return the ith node in sorted order.
[[7.43|Solution]]


Back to [[Chapter List]]</text>
      <sha1>ilvv5aqt5h0lqq3hlmh6qnlvx52iud1</sha1>
    </revision>
    <revision>
      <id>452</id>
      <parentid>358</parentid>
      <timestamp>2020-10-01T18:08:55Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <minor/>
      <comment>Protected "[[Chapter 7]]" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="19152">=Graph Traversal=

===Simulating Graph Algorithms===

:[[7.1]]. For the following graphs &lt;math&gt;G_1&lt;/math&gt; (left) and &lt;math&gt;G_2&lt;/math&gt; (right):
:(see book for figures)

:(a)Report the order of the vertices encountered on a breadth-first search starting from vertex &lt;math&gt;A&lt;/math&gt;. Break all ties by picking the vertices in alphabetical order (i.e., &lt;math&gt;A&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt;).
:(b)Report the order of the vertices encountered on a depth-first search starting from vertex &lt;math&gt;A&lt;/math&gt;. Break all ties by picking the vertices in alphabetical order (i.e., &lt;math&gt;A&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt;).
[[7.1|Solution]]


:7.2. Do a topological sort of the following graph &lt;math&gt;G&lt;/math&gt;:
:(see book for figure)

===Traversal===

:[[7.3]]. Prove that there is a unique path between any pair of vertices in a tree.
[[7.3|Solution]]


:7.4. Prove that in a breadth-first search on a undirected graph &lt;math&gt;G&lt;/math&gt;, every edge is either a tree edge or a cross edge, where &lt;math&gt;x&lt;/math&gt; is neither an ancestor nor descendant of &lt;math&gt;y&lt;/math&gt; in cross edge &lt;math&gt;(x, y)&lt;/math&gt;.


:[[7.5]]. Give a linear algorithm to compute the chromatic number of graphs where each vertex has degree at most 2. Any bipartite graph has a chromatic number of 2. Must such graphs be bipartite?
[[7.5|Solution]]


:7.6. You are given a connected, undirected graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges. Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm to identify an edge you can remove from &lt;math&gt;G&lt;/math&gt; while still leaving &lt;math&gt;G&lt;/math&gt; connected, if one exists. Can you reduce the running time to &lt;math&gt;O(n)&lt;/math&gt;?


:[[7.7]]. In breadth-first and depth-first search, an undiscovered node is marked ''discovered'' when it is first encountered, and marked ''processed'' when it has been completely searched. At any given moment, several nodes might be simultaneously in the ''discovered'' state.
:(a) Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that &lt;math&gt;\Theta(n)&lt;/math&gt; nodes are simultaneously in the ''discovered'' state during a ''breadth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.
:(b) Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that &lt;math&gt;\Theta(n)&lt;/math&gt; nodes are simultaneously in the ''discovered'' state during a ''depth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.
:(c)  Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that at some point &lt;math&gt;\Theta(n)&lt;/math&gt; nodes remain ''undiscovered'', while &lt;math&gt;\Theta(n)&lt;/math&gt; nodes have been ''processed'' during a ''depth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.(Note, there may also be ''discovered'' nodes.)
[[7.7|Solution]]


:7.8. Given pre-order and in-order traversals of a binary tree (discussed in Section 3.4.1), is it possible to reconstruct the tree? If so, sketch an algorithm to do it. If not, give a counterexample. Repeat the problem if you are given the pre-order and post-order traversals.


:[[7.9]]. Present correct and efficient algorithms to convert an undirected graph &lt;math&gt;G&lt;/math&gt; between the following graph data structures. You must give the time complexity of each algorithm, assuming &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges.
:(a)Convert from an adjacency matrix to adjacency lists.
:(b)Convert from an adjacency list to an incidence matrix. An incidence matrix &lt;math&gt;M&lt;/math&gt; has a row for each vertex and a column for each edge, such that &lt;math&gt;M[i,j]=1&lt;/math&gt; if vertex &lt;math&gt;i&lt;/math&gt; is part of edge &lt;math&gt;j&lt;/math&gt;, otherwise &lt;math&gt;M[i,j] = 0&lt;/math&gt;.
:(c)Convert from an incidence matrix to adjacency lists.
[[7.9|Solution]]


:7.10. Suppose an arithmetic expression is given as a tree. Each leaf is an integer and each internal node is one of the standard arithmetical operations &lt;math&gt;(+, -, *, /)&lt;/math&gt;. For example, the expression &lt;math&gt;2+3*4+(3*4)/5&lt;/math&gt; is represented by the tree in Figure 7.17(a). Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for evaluating such an expression, where there are &lt;math&gt;n&lt;/math&gt; nodes in the tree.


:[[7.11]]. Suppose an arithmetic expression is given as a DAG (directed acyclic graph) with common subexpressions removed. Each leaf is an integer and each internal node is one of the standard arithmetical operations &lt;math&gt;(+,-,*,/)&lt;/math&gt;. For example, the expression &lt;math&gt;2+3*4+(3*4)/5&lt;/math&gt; is represented by the DAG in Figure (see book)(b). Give an &lt;math&gt;O(n+m)&lt;/math&gt; algorithm for evaluating such a DAG, where there are &lt;math&gt;n&lt;/math&gt; nodes and &lt;math&gt;m&lt;/math&gt; edges in the DAG. Hint: modify an algorithm for the tree case to achieve the desired efficiency.
[[7.11|Solution]]


:7.12. The war story of Section 7.4 (page 210) describes an algorithm for constructing the dual graph of the triangulation efficiently, although it does not guarantee linear time. Give a worst-case linear algorithm for the problem.

===Applications===

:[[7.13]]. The Chutes and Ladders game has a board with n cells where you seek to travel from cell 1 to cell &lt;math&gt;n&lt;/math&gt;. To move, a player throws a six-sided dice to determine how many cells forward they move. This board also contains chutes and ladders that connect certain pairs of cells. A player who lands on the mouth of a chute immediately falls back down to the cell at the other end. A player who lands on the base of a ladder immediately travels up to the cell at the top of the ladder. Suppose you have rigged the dice to give you full control of the number for each roll. Give an efficient algorithm to find the minimum number of dice throws to win.
[[7.13|Solution]]


:7.14. Plum blossom poles are a Kung Fu training technique, consisting of &lt;math&gt;n&lt;/math&gt; large posts partially sunk into the ground, with each pole &lt;math&gt;p_i&lt;/math&gt; at position &lt;math&gt;(x_i, y_i)&lt;/math&gt;. Students practice martial arts techniques by stepping from the top of one pole to the top of another pole. In order to keep balance, each step must be more than &lt;math&gt;d&lt;/math&gt; meters but less than &lt;math&gt;2d&lt;/math&gt; meters. Give an efficient algorithm to find a safe path from pole &lt;math&gt;p_s&lt;/math&gt; to &lt;math&gt;p_t&lt;/math&gt; if it exists.


:[[7.15]]. You are planning the seating arrangement for a wedding given a list of guests, &lt;math&gt;V&lt;/math&gt;. For each guest &lt;math&gt;g&lt;/math&gt; you have a list of all other guests who are on bad terms with them. Feelings are reciprocal: if &lt;math&gt;h&lt;/math&gt; is on bad terms with &lt;math&gt;g&lt;/math&gt;, then &lt;math&gt;g&lt;/math&gt; is on bad terms with &lt;math&gt;h&lt;/math&gt;. Your goal is to arrange the seating such that no pair of guests sitting at the same table are on bad terms with each other. There will be only two tables at the wedding. Give an efficient algorithm to find an acceptable seating arrangement if one exists.
[[7.15|Solution]]

===Algorithm Design===

:7.16. The ''square'' of a directed graph &lt;math&gt;G=(V,E)&lt;/math&gt; is the graph &lt;math&gt;G^2=(V,E^2)&lt;/math&gt; such that &lt;math&gt;(u,w) \in E^2&lt;/math&gt; iff there exists &lt;math&gt;v \in V&lt;/math&gt; such that &lt;math&gt;(u,v) \in E&lt;/math&gt; and &lt;math&gt;(v,w) \in E&lt;/math&gt;; i.e., there is a path of exactly two edges from &lt;math&gt;u&lt;/math&gt; to &lt;math&gt;w&lt;/math&gt;.
:Give efficient algorithms for both adjacency lists and matrices.


:[[7.17]]. A ''vertex cover'' of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V'&lt;/math&gt; such that each edge in &lt;math&gt;E&lt;/math&gt; is incident on at least one vertex of &lt;math&gt;V'&lt;/math&gt;.
:(a)Give an efficient algorithm to find a minimum-size vertex cover if &lt;math&gt;G&lt;/math&gt; is a tree.
:(b)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree such that the weight of each vertex is equal to the degree of that vertex. Give an efficient algorithm to find a minimum-weight vertex cover of &lt;math&gt;G&lt;/math&gt;.
:(c)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree with arbitrary weights associated with the vertices. Give an efficient algorithm to find a minimum-weight vertex cover of &lt;math&gt;G&lt;/math&gt;.
[[7.17|Solution]]


:7.18. A ''vertex cover'' of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V' \in V&lt;/math&gt; such that every edge in &lt;math&gt;E&lt;/math&gt; contains at least one vertex from &lt;math&gt;V'&lt;/math&gt;. Delete all the leaves from any depth-first search tree of &lt;math&gt;G&lt;/math&gt;. Must the remaining vertices form a vertex cover of &lt;math&gt;G&lt;/math&gt;? Give a proof or a counterexample.


:[[7.19]]. An ''independent set'' of an undirected graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a set of vertices $U$ such that no edge in &lt;math&gt;E&lt;/math&gt; is incident on two vertices of &lt;math&gt;U&lt;/math&gt;.
:(a)Give an efficient algorithm to find a maximum-size independent set if &lt;math&gt;G&lt;/math&gt; is a tree.
:(b)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree with weights associated with the vertices such that the weight of each vertex is equal to the degree of that vertex. Give an efficient algorithm to find a maximum independent set of &lt;math&gt;G&lt;/math&gt;.
:(c)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree with arbitrary weights associated with the vertices. Give an efficient algorithm to find a maximum independent set of &lt;math&gt;G&lt;/math&gt;.
[[7.19|Solution]]


:7.20. A ''vertex cover'' of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V' \in V&lt;/math&gt; such that every edge in &lt;math&gt;E&lt;/math&gt; contains ''at least one'' vertex from &lt;math&gt;V'&lt;/math&gt;. An ''independent set'' of graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V' \in V&lt;/math&gt; such that no edge in &lt;math&gt;E&lt;/math&gt; contains both vertices from &lt;math&gt;V'&lt;/math&gt;.
:An ''independent vertex cover'' is a subset of vertices that is both an independent set and a vertex cover of &lt;math&gt;G&lt;/math&gt;. Give an efficient algorithm for testing whether &lt;math&gt;G&lt;/math&gt; contains an independent vertex cover. What classical graph problem does this reduce to?


:[[7.21]]. Consider the problem of determining whether a given undirected graph &lt;math&gt;G=(V,E)&lt;/math&gt; contains a ''triangle'' or cycle of length 3. 
:(a)Give an  &lt;math&gt;O(|V|^3)&lt;/math&gt; to find a triangle if one exists.
:(b)Improve your algorithm to run in time &lt;math&gt;O(|V| \cdot |E|)&lt;/math&gt;. You may assume &lt;math&gt;|V| \leq |E|&lt;/math&gt;. 
:Observe that these bounds gives you time to convert between the adjacency matrix and adjacency list representations of &lt;math&gt;G&lt;/math&gt;.
[[7.21|Solution]]


:7.22. Consider a set of movies &lt;math&gt;M_1, M_2, \ldots, M_k&lt;/math&gt;. There is a set of customers, each one of which indicates the two movies they would like to see this weekend. Movies are shown on Saturday evening and Sunday evening. Multiple movies may be screened at the same time. 
:You must decide which movies should be televised on Saturday and which on Sunday, so that every customer gets to see the two movies they desire. Is there a schedule where each movie is shown at most once? Design an efficient algorithm to find such a schedule if one exists.


:[[7.23]].The ''diameter'' of a tree &lt;math&gt;T=(V,E)&lt;/math&gt; is given by 
&lt;center&gt;&lt;math&gt;\max_{u,v\in V} \delta(u,v)&lt;/math&gt;&lt;/center&gt;
:(where &lt;math&gt;\delta(u,v)&lt;/math&gt; is the number of edges on the path from &lt;math&gt;u&lt;/math&gt; to &lt;math&gt;v&lt;/math&gt;).  Describe an efficient algorithm to compute the diameter of a tree, and show the correctness and analyze the running time of your algorithm.
[[7.23|Solution]]


:7.24. Given an undirected graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges, and an integer &lt;math&gt;k&lt;/math&gt;, give an &lt;math&gt;O(m+n)&lt;/math&gt; algorithm that finds the maximum induced subgraph &lt;math&gt;H&lt;/math&gt; of &lt;math&gt;G&lt;/math&gt; such that each vertex in &lt;math&gt;H&lt;/math&gt; has degree &lt;math&gt;\geq k&lt;/math&gt;, or prove that no such graph exists. An induced subgraph &lt;math&gt;F=(U,R)&lt;/math&gt; of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of &lt;math&gt;U&lt;/math&gt; of the vertices &lt;math&gt;V&lt;/math&gt; of &lt;math&gt;G&lt;/math&gt;, and all edges &lt;math&gt;R&lt;/math&gt; of &lt;math&gt;G&lt;/math&gt; such that both vertices of each edge are in &lt;math&gt;U&lt;/math&gt;.


:[[7.25]]. Let &lt;math&gt;v&lt;/math&gt; and &lt;math&gt;w&lt;/math&gt; be two vertices in a directed graph &lt;math&gt;G=(V,E &lt;/math&gt;. Design a linear-time algorithm to find the ''number'' of different shortest paths (not necessarily vertex disjoint) between &lt;math&gt;v&lt;/math&gt; and &lt;math&gt;w&lt;/math&gt;. Note: the edges in &lt;math&gt;G&lt;/math&gt; are unweighted.
[[7.25|Solution]]


:7.26. Design a linear-time algorithm to eliminate each vertex &lt;math&gt;v&lt;/math&gt; of degree 2 from a graph by replacing edges &lt;math&gt;(u,v)&lt;/math&gt; and &lt;math&gt;(v,w)&lt;/math&gt; by an edge &lt;math&gt;(u,w)&lt;/math&gt;. We also seek to eliminate multiple copies of edges by replacing them with a single edge. Note that removing multiple copies of an edge may create a new vertex of degree 2, which has to be removed, and that removing a vertex of degree 2 may create multiple edges, which also must be removed.

===Directed Graphs===

:[[7.27]]. The reverse of a directed graph &lt;math&gt;G = (V, E)&lt;/math&gt; is another directed graph &lt;math&gt;G^R = (V, E^R)&lt;/math&gt; on the same vertex set, but with all edges reversed; that is, &lt;math&gt;E^R = {(v, u) : (u, v) \in E}&lt;/math&gt;. Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm for computing the reverse of an &lt;math&gt;n&lt;/math&gt;-vertex &lt;math&gt;m&lt;/math&gt;-edge graph in adjacency list format.
[[7.27|Solution]]


:7.28. Your job is to arrange &lt;math&gt;n&lt;/math&gt; ill-behaved children in a straight line, facing front. You are given a list of &lt;math&gt;m&lt;/math&gt; statements of the form “&lt;math&gt;i&lt;/math&gt; hates &lt;math&gt;j&lt;/math&gt;.” If &lt;math&gt;i&lt;/math&gt; hates &lt;math&gt;j&lt;/math&gt;, then you do not want to put &lt;math&gt;i&lt;/math&gt; somewhere behind &lt;math&gt;j&lt;/math&gt;, because then &lt;math&gt;i&lt;/math&gt; is capable of throwing something at &lt;math&gt;j&lt;/math&gt;.
:(a) Give an algorithm that orders the line (or says that it is not possible) in &lt;math&gt;O(m + n)&lt;/math&gt; time.
:(b) Suppose instead you want to arrange the children in rows such that if &lt;math&gt;i&lt;/math&gt; hates &lt;math&gt;j&lt;/math&gt;, then &lt;math&gt;i&lt;/math&gt; must be in a lower numbered row than &lt;math&gt;j&lt;/math&gt;. Give an efficient algorithm to find the minimum number of rows needed, if it is possible.


:[[7.29]]. A particular academic program has &lt;math&gt;n&lt;/math&gt; required courses, certain pairs of which have prerequisite relations so that &lt;math&gt;(x, y)&lt;/math&gt; means you must take course &lt;math&gt;x&lt;/math&gt; before &lt;math&gt;y&lt;/math&gt;. How would you analyze the prerequisite pairs to make sure it is possible for people to complete the program?
[[7.29|Solution]]


:7.30. Gotcha-solitaire is a game on a deck with &lt;math&gt;n&lt;/math&gt; distinct cards (all face up) and &lt;math&gt;m&lt;/math&gt; gotcha pairs &lt;math&gt;(i, j)&lt;/math&gt; such that card &lt;math&gt;i&lt;/math&gt; must be played sometime before card &lt;math&gt;j&lt;/math&gt;. You play by sequentially choosing cards, and win if you pick up the entire deck without violating any gotcha pair constraints. Give an efficient algorithm to find a winning pickup order if one exists.


:[[7.31]]. You are given a list of &lt;math&gt;n&lt;/math&gt; words each of length &lt;math&gt;k&lt;/math&gt; in a language you don’t know, although you are told that words are sorted in lexicographic (alphabetical) order. Reconstruct the order of the α alphabet letters (characters) in that language. 
:For example, if the strings are &lt;math&gt;{QQZ, QZZ, XQZ, XQX, XXX}&lt;/math&gt;, the character order must be &lt;math&gt;Q&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt; before &lt;math&gt;X&lt;/math&gt;.
:(a) Give an algorithm to efficiently reconstruct this character order. (Hint: use a graph structure, where each node represents one letter.)
:(b) What is its running time, as a function of &lt;math&gt;n, k&lt;/math&gt;, and &lt;math&gt;\alpha&lt;/math&gt;?
[[7.31|Solution]]


:7.32. A ''weakly connected component'' in a directed graph is a connected component ignoring the direction of the edges. Adding a single directed edge to a directed graph can reduce the number of weakly connected components, but by at most how many components? What about the number of strongly connected components?


:[[7.33]]. Design a linear-time algorithm that, given an undirected graph &lt;math&gt;G&lt;/math&gt; and a particular edge &lt;math&gt;e&lt;/math&gt; in it, determines whether &lt;math&gt;G&lt;/math&gt; has a cycle containing &lt;math&gt;e&lt;/math&gt;.
[[7.33|Solution]]


:7.34. An ''arborescence'' of a directed graph &lt;math&gt;G&lt;/math&gt; is a rooted tree such that there is a directed path from the root to every other vertex in the graph. Give an efficient and correct algorithm to test whether &lt;math&gt;G&lt;/math&gt; contains an arborescence, and its time complexity.


:[[7.35]]. A mother vertex in a directed graph &lt;math&gt;G = (V, E)&lt;/math&gt; is a vertex &lt;math&gt;v&lt;/math&gt; such that all other vertices &lt;math&gt;G&lt;/math&gt; can be reached by a directed path from &lt;math&gt;v&lt;/math&gt;. 
:(a) Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm to test whether a given vertex &lt;math&gt;v&lt;/math&gt; is a mother of &lt;math&gt;G&lt;/math&gt;, where &lt;math&gt;n = |V|&lt;/math&gt; and &lt;math&gt;m = |E|&lt;/math&gt;. 
:(b) Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm to test whether graph &lt;math&gt;G&lt;/math&gt; contains a mother vertex.
[[7.35|Solution]]


:7.36. Let &lt;math&gt;G&lt;/math&gt; be a directed graph. We say that &lt;math&gt;G&lt;/math&gt; is ''k-cyclic'' if every (not necessarily simple) cycle in &lt;math&gt;G&lt;/math&gt; contains at most &lt;math&gt;k&lt;/math&gt; distinct nodes. Give a linear-time algorithm to determine if a directed graph &lt;math&gt;G&lt;/math&gt; is &lt;math&gt;k&lt;/math&gt;-cyclic, where &lt;math&gt;G&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt; are given as inputs. Justify the correctness and running time of your algorithm.


:[[7.37]]. A ''tournament'' is a directed graph formed by taking the complete undirected graph and assigning arbitrary directions on the edges—that is, a graph &lt;math&gt;G = (V, E)&lt;/math&gt; such that for all &lt;math&gt;u,v \in V&lt;/math&gt;, exactly one of &lt;math&gt;(u, v)&lt;/math&gt; or &lt;math&gt;(v, u)&lt;/math&gt; is in &lt;math&gt;E&lt;/math&gt;. Show that every tournament has a Hamiltonian path—that is, a path that visits every vertex exactly once. Give an algorithm to find this path.
[[7.37|Solution]]

===Articulation Vertices===

:7.38. An articulation vertex of a connected graph &lt;math&gt;G&lt;/math&gt; is a vertex whose deletion disconnects &lt;math&gt;G&lt;/math&gt;. Let &lt;math&gt;G&lt;/math&gt; be a graph with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges. Give a simple &lt;math&gt;O(n+m)&lt;/math&gt; algorithm for finding a vertex of &lt;math&gt;G&lt;/math&gt; that is not an articulation vertex—that is, whose deletion does not disconnect &lt;math&gt;G&lt;/math&gt;.


:[[7.39]]. Following up on the previous problem, give an &lt;math&gt;O(n+m)&lt;/math&gt; algorithm that finds a deletion order for the &lt;math&gt;n&lt;/math&gt; vertices such that no deletion disconnects the graph. (Hint: think DFS/BFS.)
[[7.39|Solution]]


:7.40. Suppose &lt;math&gt;G&lt;/math&gt; is a connected undirected graph. An edge &lt;math&gt;e&lt;/math&gt; whose removal disconnects the graph is called a bridge. Must every bridge &lt;math&gt;e&lt;/math&gt; be an edge in a depth-first search tree of &lt;math&gt;G&lt;/math&gt;? Give a proof or a counterexample.


:[[7.41]]. A city that only has two-way streets has decided to change them all into one-way streets. They want to ensure that the new network is strongly connected so everyone can legally drive anywhere in the city and back.
:(a) Let &lt;math&gt;G&lt;/math&gt; be the original undirected graph. Prove that there is a way to properly orient/direct the edges of &lt;math&gt;G&lt;/math&gt; provided &lt;math&gt;G&lt;/math&gt; does not contain a bridge.
:(b) Give an efficient algorithm to orient the edges of a bridgeless graph &lt;math&gt;G&lt;/math&gt; so the result is strongly connected.
[[7.41|Solution]]

===Interview Problems===

:7.42. Which data structures are used in depth-first and breath-first search?


:[[7.43]]. Write a function to traverse binary search tree and return the ith node in sorted order.
[[7.43|Solution]]


Back to [[Chapter List]]</text>
      <sha1>ilvv5aqt5h0lqq3hlmh6qnlvx52iud1</sha1>
    </revision>
    <revision>
      <id>453</id>
      <parentid>452</parentid>
      <timestamp>2020-10-01T18:09:33Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Simulating Graph Algorithms */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="19154">=Graph Traversal=

===Simulating Graph Algorithms===

:[[7.1]]. For the following graphs &lt;math&gt;G_1&lt;/math&gt; (left) and &lt;math&gt;G_2&lt;/math&gt; (right):
:(see book for figures)

:(a) Report the order of the vertices encountered on a breadth-first search starting from vertex &lt;math&gt;A&lt;/math&gt;. Break all ties by picking the vertices in alphabetical order (i.e., &lt;math&gt;A&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt;).
:(b) Report the order of the vertices encountered on a depth-first search starting from vertex &lt;math&gt;A&lt;/math&gt;. Break all ties by picking the vertices in alphabetical order (i.e., &lt;math&gt;A&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt;).
[[7.1|Solution]]


:7.2. Do a topological sort of the following graph &lt;math&gt;G&lt;/math&gt;:
:(see book for figure)

===Traversal===

:[[7.3]]. Prove that there is a unique path between any pair of vertices in a tree.
[[7.3|Solution]]


:7.4. Prove that in a breadth-first search on a undirected graph &lt;math&gt;G&lt;/math&gt;, every edge is either a tree edge or a cross edge, where &lt;math&gt;x&lt;/math&gt; is neither an ancestor nor descendant of &lt;math&gt;y&lt;/math&gt; in cross edge &lt;math&gt;(x, y)&lt;/math&gt;.


:[[7.5]]. Give a linear algorithm to compute the chromatic number of graphs where each vertex has degree at most 2. Any bipartite graph has a chromatic number of 2. Must such graphs be bipartite?
[[7.5|Solution]]


:7.6. You are given a connected, undirected graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges. Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm to identify an edge you can remove from &lt;math&gt;G&lt;/math&gt; while still leaving &lt;math&gt;G&lt;/math&gt; connected, if one exists. Can you reduce the running time to &lt;math&gt;O(n)&lt;/math&gt;?


:[[7.7]]. In breadth-first and depth-first search, an undiscovered node is marked ''discovered'' when it is first encountered, and marked ''processed'' when it has been completely searched. At any given moment, several nodes might be simultaneously in the ''discovered'' state.
:(a) Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that &lt;math&gt;\Theta(n)&lt;/math&gt; nodes are simultaneously in the ''discovered'' state during a ''breadth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.
:(b) Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that &lt;math&gt;\Theta(n)&lt;/math&gt; nodes are simultaneously in the ''discovered'' state during a ''depth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.
:(c)  Describe a graph on &lt;math&gt;n&lt;/math&gt; vertices and a particular starting vertex &lt;math&gt;v&lt;/math&gt; such that at some point &lt;math&gt;\Theta(n)&lt;/math&gt; nodes remain ''undiscovered'', while &lt;math&gt;\Theta(n)&lt;/math&gt; nodes have been ''processed'' during a ''depth-first search'' starting from &lt;math&gt;v&lt;/math&gt;.(Note, there may also be ''discovered'' nodes.)
[[7.7|Solution]]


:7.8. Given pre-order and in-order traversals of a binary tree (discussed in Section 3.4.1), is it possible to reconstruct the tree? If so, sketch an algorithm to do it. If not, give a counterexample. Repeat the problem if you are given the pre-order and post-order traversals.


:[[7.9]]. Present correct and efficient algorithms to convert an undirected graph &lt;math&gt;G&lt;/math&gt; between the following graph data structures. You must give the time complexity of each algorithm, assuming &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges.
:(a)Convert from an adjacency matrix to adjacency lists.
:(b)Convert from an adjacency list to an incidence matrix. An incidence matrix &lt;math&gt;M&lt;/math&gt; has a row for each vertex and a column for each edge, such that &lt;math&gt;M[i,j]=1&lt;/math&gt; if vertex &lt;math&gt;i&lt;/math&gt; is part of edge &lt;math&gt;j&lt;/math&gt;, otherwise &lt;math&gt;M[i,j] = 0&lt;/math&gt;.
:(c)Convert from an incidence matrix to adjacency lists.
[[7.9|Solution]]


:7.10. Suppose an arithmetic expression is given as a tree. Each leaf is an integer and each internal node is one of the standard arithmetical operations &lt;math&gt;(+, -, *, /)&lt;/math&gt;. For example, the expression &lt;math&gt;2+3*4+(3*4)/5&lt;/math&gt; is represented by the tree in Figure 7.17(a). Give an &lt;math&gt;O(n)&lt;/math&gt; algorithm for evaluating such an expression, where there are &lt;math&gt;n&lt;/math&gt; nodes in the tree.


:[[7.11]]. Suppose an arithmetic expression is given as a DAG (directed acyclic graph) with common subexpressions removed. Each leaf is an integer and each internal node is one of the standard arithmetical operations &lt;math&gt;(+,-,*,/)&lt;/math&gt;. For example, the expression &lt;math&gt;2+3*4+(3*4)/5&lt;/math&gt; is represented by the DAG in Figure (see book)(b). Give an &lt;math&gt;O(n+m)&lt;/math&gt; algorithm for evaluating such a DAG, where there are &lt;math&gt;n&lt;/math&gt; nodes and &lt;math&gt;m&lt;/math&gt; edges in the DAG. Hint: modify an algorithm for the tree case to achieve the desired efficiency.
[[7.11|Solution]]


:7.12. The war story of Section 7.4 (page 210) describes an algorithm for constructing the dual graph of the triangulation efficiently, although it does not guarantee linear time. Give a worst-case linear algorithm for the problem.

===Applications===

:[[7.13]]. The Chutes and Ladders game has a board with n cells where you seek to travel from cell 1 to cell &lt;math&gt;n&lt;/math&gt;. To move, a player throws a six-sided dice to determine how many cells forward they move. This board also contains chutes and ladders that connect certain pairs of cells. A player who lands on the mouth of a chute immediately falls back down to the cell at the other end. A player who lands on the base of a ladder immediately travels up to the cell at the top of the ladder. Suppose you have rigged the dice to give you full control of the number for each roll. Give an efficient algorithm to find the minimum number of dice throws to win.
[[7.13|Solution]]


:7.14. Plum blossom poles are a Kung Fu training technique, consisting of &lt;math&gt;n&lt;/math&gt; large posts partially sunk into the ground, with each pole &lt;math&gt;p_i&lt;/math&gt; at position &lt;math&gt;(x_i, y_i)&lt;/math&gt;. Students practice martial arts techniques by stepping from the top of one pole to the top of another pole. In order to keep balance, each step must be more than &lt;math&gt;d&lt;/math&gt; meters but less than &lt;math&gt;2d&lt;/math&gt; meters. Give an efficient algorithm to find a safe path from pole &lt;math&gt;p_s&lt;/math&gt; to &lt;math&gt;p_t&lt;/math&gt; if it exists.


:[[7.15]]. You are planning the seating arrangement for a wedding given a list of guests, &lt;math&gt;V&lt;/math&gt;. For each guest &lt;math&gt;g&lt;/math&gt; you have a list of all other guests who are on bad terms with them. Feelings are reciprocal: if &lt;math&gt;h&lt;/math&gt; is on bad terms with &lt;math&gt;g&lt;/math&gt;, then &lt;math&gt;g&lt;/math&gt; is on bad terms with &lt;math&gt;h&lt;/math&gt;. Your goal is to arrange the seating such that no pair of guests sitting at the same table are on bad terms with each other. There will be only two tables at the wedding. Give an efficient algorithm to find an acceptable seating arrangement if one exists.
[[7.15|Solution]]

===Algorithm Design===

:7.16. The ''square'' of a directed graph &lt;math&gt;G=(V,E)&lt;/math&gt; is the graph &lt;math&gt;G^2=(V,E^2)&lt;/math&gt; such that &lt;math&gt;(u,w) \in E^2&lt;/math&gt; iff there exists &lt;math&gt;v \in V&lt;/math&gt; such that &lt;math&gt;(u,v) \in E&lt;/math&gt; and &lt;math&gt;(v,w) \in E&lt;/math&gt;; i.e., there is a path of exactly two edges from &lt;math&gt;u&lt;/math&gt; to &lt;math&gt;w&lt;/math&gt;.
:Give efficient algorithms for both adjacency lists and matrices.


:[[7.17]]. A ''vertex cover'' of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V'&lt;/math&gt; such that each edge in &lt;math&gt;E&lt;/math&gt; is incident on at least one vertex of &lt;math&gt;V'&lt;/math&gt;.
:(a)Give an efficient algorithm to find a minimum-size vertex cover if &lt;math&gt;G&lt;/math&gt; is a tree.
:(b)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree such that the weight of each vertex is equal to the degree of that vertex. Give an efficient algorithm to find a minimum-weight vertex cover of &lt;math&gt;G&lt;/math&gt;.
:(c)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree with arbitrary weights associated with the vertices. Give an efficient algorithm to find a minimum-weight vertex cover of &lt;math&gt;G&lt;/math&gt;.
[[7.17|Solution]]


:7.18. A ''vertex cover'' of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V' \in V&lt;/math&gt; such that every edge in &lt;math&gt;E&lt;/math&gt; contains at least one vertex from &lt;math&gt;V'&lt;/math&gt;. Delete all the leaves from any depth-first search tree of &lt;math&gt;G&lt;/math&gt;. Must the remaining vertices form a vertex cover of &lt;math&gt;G&lt;/math&gt;? Give a proof or a counterexample.


:[[7.19]]. An ''independent set'' of an undirected graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a set of vertices $U$ such that no edge in &lt;math&gt;E&lt;/math&gt; is incident on two vertices of &lt;math&gt;U&lt;/math&gt;.
:(a)Give an efficient algorithm to find a maximum-size independent set if &lt;math&gt;G&lt;/math&gt; is a tree.
:(b)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree with weights associated with the vertices such that the weight of each vertex is equal to the degree of that vertex. Give an efficient algorithm to find a maximum independent set of &lt;math&gt;G&lt;/math&gt;.
:(c)Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a tree with arbitrary weights associated with the vertices. Give an efficient algorithm to find a maximum independent set of &lt;math&gt;G&lt;/math&gt;.
[[7.19|Solution]]


:7.20. A ''vertex cover'' of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V' \in V&lt;/math&gt; such that every edge in &lt;math&gt;E&lt;/math&gt; contains ''at least one'' vertex from &lt;math&gt;V'&lt;/math&gt;. An ''independent set'' of graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of vertices &lt;math&gt;V' \in V&lt;/math&gt; such that no edge in &lt;math&gt;E&lt;/math&gt; contains both vertices from &lt;math&gt;V'&lt;/math&gt;.
:An ''independent vertex cover'' is a subset of vertices that is both an independent set and a vertex cover of &lt;math&gt;G&lt;/math&gt;. Give an efficient algorithm for testing whether &lt;math&gt;G&lt;/math&gt; contains an independent vertex cover. What classical graph problem does this reduce to?


:[[7.21]]. Consider the problem of determining whether a given undirected graph &lt;math&gt;G=(V,E)&lt;/math&gt; contains a ''triangle'' or cycle of length 3. 
:(a)Give an  &lt;math&gt;O(|V|^3)&lt;/math&gt; to find a triangle if one exists.
:(b)Improve your algorithm to run in time &lt;math&gt;O(|V| \cdot |E|)&lt;/math&gt;. You may assume &lt;math&gt;|V| \leq |E|&lt;/math&gt;. 
:Observe that these bounds gives you time to convert between the adjacency matrix and adjacency list representations of &lt;math&gt;G&lt;/math&gt;.
[[7.21|Solution]]


:7.22. Consider a set of movies &lt;math&gt;M_1, M_2, \ldots, M_k&lt;/math&gt;. There is a set of customers, each one of which indicates the two movies they would like to see this weekend. Movies are shown on Saturday evening and Sunday evening. Multiple movies may be screened at the same time. 
:You must decide which movies should be televised on Saturday and which on Sunday, so that every customer gets to see the two movies they desire. Is there a schedule where each movie is shown at most once? Design an efficient algorithm to find such a schedule if one exists.


:[[7.23]].The ''diameter'' of a tree &lt;math&gt;T=(V,E)&lt;/math&gt; is given by 
&lt;center&gt;&lt;math&gt;\max_{u,v\in V} \delta(u,v)&lt;/math&gt;&lt;/center&gt;
:(where &lt;math&gt;\delta(u,v)&lt;/math&gt; is the number of edges on the path from &lt;math&gt;u&lt;/math&gt; to &lt;math&gt;v&lt;/math&gt;).  Describe an efficient algorithm to compute the diameter of a tree, and show the correctness and analyze the running time of your algorithm.
[[7.23|Solution]]


:7.24. Given an undirected graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges, and an integer &lt;math&gt;k&lt;/math&gt;, give an &lt;math&gt;O(m+n)&lt;/math&gt; algorithm that finds the maximum induced subgraph &lt;math&gt;H&lt;/math&gt; of &lt;math&gt;G&lt;/math&gt; such that each vertex in &lt;math&gt;H&lt;/math&gt; has degree &lt;math&gt;\geq k&lt;/math&gt;, or prove that no such graph exists. An induced subgraph &lt;math&gt;F=(U,R)&lt;/math&gt; of a graph &lt;math&gt;G=(V,E)&lt;/math&gt; is a subset of &lt;math&gt;U&lt;/math&gt; of the vertices &lt;math&gt;V&lt;/math&gt; of &lt;math&gt;G&lt;/math&gt;, and all edges &lt;math&gt;R&lt;/math&gt; of &lt;math&gt;G&lt;/math&gt; such that both vertices of each edge are in &lt;math&gt;U&lt;/math&gt;.


:[[7.25]]. Let &lt;math&gt;v&lt;/math&gt; and &lt;math&gt;w&lt;/math&gt; be two vertices in a directed graph &lt;math&gt;G=(V,E &lt;/math&gt;. Design a linear-time algorithm to find the ''number'' of different shortest paths (not necessarily vertex disjoint) between &lt;math&gt;v&lt;/math&gt; and &lt;math&gt;w&lt;/math&gt;. Note: the edges in &lt;math&gt;G&lt;/math&gt; are unweighted.
[[7.25|Solution]]


:7.26. Design a linear-time algorithm to eliminate each vertex &lt;math&gt;v&lt;/math&gt; of degree 2 from a graph by replacing edges &lt;math&gt;(u,v)&lt;/math&gt; and &lt;math&gt;(v,w)&lt;/math&gt; by an edge &lt;math&gt;(u,w)&lt;/math&gt;. We also seek to eliminate multiple copies of edges by replacing them with a single edge. Note that removing multiple copies of an edge may create a new vertex of degree 2, which has to be removed, and that removing a vertex of degree 2 may create multiple edges, which also must be removed.

===Directed Graphs===

:[[7.27]]. The reverse of a directed graph &lt;math&gt;G = (V, E)&lt;/math&gt; is another directed graph &lt;math&gt;G^R = (V, E^R)&lt;/math&gt; on the same vertex set, but with all edges reversed; that is, &lt;math&gt;E^R = {(v, u) : (u, v) \in E}&lt;/math&gt;. Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm for computing the reverse of an &lt;math&gt;n&lt;/math&gt;-vertex &lt;math&gt;m&lt;/math&gt;-edge graph in adjacency list format.
[[7.27|Solution]]


:7.28. Your job is to arrange &lt;math&gt;n&lt;/math&gt; ill-behaved children in a straight line, facing front. You are given a list of &lt;math&gt;m&lt;/math&gt; statements of the form “&lt;math&gt;i&lt;/math&gt; hates &lt;math&gt;j&lt;/math&gt;.” If &lt;math&gt;i&lt;/math&gt; hates &lt;math&gt;j&lt;/math&gt;, then you do not want to put &lt;math&gt;i&lt;/math&gt; somewhere behind &lt;math&gt;j&lt;/math&gt;, because then &lt;math&gt;i&lt;/math&gt; is capable of throwing something at &lt;math&gt;j&lt;/math&gt;.
:(a) Give an algorithm that orders the line (or says that it is not possible) in &lt;math&gt;O(m + n)&lt;/math&gt; time.
:(b) Suppose instead you want to arrange the children in rows such that if &lt;math&gt;i&lt;/math&gt; hates &lt;math&gt;j&lt;/math&gt;, then &lt;math&gt;i&lt;/math&gt; must be in a lower numbered row than &lt;math&gt;j&lt;/math&gt;. Give an efficient algorithm to find the minimum number of rows needed, if it is possible.


:[[7.29]]. A particular academic program has &lt;math&gt;n&lt;/math&gt; required courses, certain pairs of which have prerequisite relations so that &lt;math&gt;(x, y)&lt;/math&gt; means you must take course &lt;math&gt;x&lt;/math&gt; before &lt;math&gt;y&lt;/math&gt;. How would you analyze the prerequisite pairs to make sure it is possible for people to complete the program?
[[7.29|Solution]]


:7.30. Gotcha-solitaire is a game on a deck with &lt;math&gt;n&lt;/math&gt; distinct cards (all face up) and &lt;math&gt;m&lt;/math&gt; gotcha pairs &lt;math&gt;(i, j)&lt;/math&gt; such that card &lt;math&gt;i&lt;/math&gt; must be played sometime before card &lt;math&gt;j&lt;/math&gt;. You play by sequentially choosing cards, and win if you pick up the entire deck without violating any gotcha pair constraints. Give an efficient algorithm to find a winning pickup order if one exists.


:[[7.31]]. You are given a list of &lt;math&gt;n&lt;/math&gt; words each of length &lt;math&gt;k&lt;/math&gt; in a language you don’t know, although you are told that words are sorted in lexicographic (alphabetical) order. Reconstruct the order of the α alphabet letters (characters) in that language. 
:For example, if the strings are &lt;math&gt;{QQZ, QZZ, XQZ, XQX, XXX}&lt;/math&gt;, the character order must be &lt;math&gt;Q&lt;/math&gt; before &lt;math&gt;Z&lt;/math&gt; before &lt;math&gt;X&lt;/math&gt;.
:(a) Give an algorithm to efficiently reconstruct this character order. (Hint: use a graph structure, where each node represents one letter.)
:(b) What is its running time, as a function of &lt;math&gt;n, k&lt;/math&gt;, and &lt;math&gt;\alpha&lt;/math&gt;?
[[7.31|Solution]]


:7.32. A ''weakly connected component'' in a directed graph is a connected component ignoring the direction of the edges. Adding a single directed edge to a directed graph can reduce the number of weakly connected components, but by at most how many components? What about the number of strongly connected components?


:[[7.33]]. Design a linear-time algorithm that, given an undirected graph &lt;math&gt;G&lt;/math&gt; and a particular edge &lt;math&gt;e&lt;/math&gt; in it, determines whether &lt;math&gt;G&lt;/math&gt; has a cycle containing &lt;math&gt;e&lt;/math&gt;.
[[7.33|Solution]]


:7.34. An ''arborescence'' of a directed graph &lt;math&gt;G&lt;/math&gt; is a rooted tree such that there is a directed path from the root to every other vertex in the graph. Give an efficient and correct algorithm to test whether &lt;math&gt;G&lt;/math&gt; contains an arborescence, and its time complexity.


:[[7.35]]. A mother vertex in a directed graph &lt;math&gt;G = (V, E)&lt;/math&gt; is a vertex &lt;math&gt;v&lt;/math&gt; such that all other vertices &lt;math&gt;G&lt;/math&gt; can be reached by a directed path from &lt;math&gt;v&lt;/math&gt;. 
:(a) Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm to test whether a given vertex &lt;math&gt;v&lt;/math&gt; is a mother of &lt;math&gt;G&lt;/math&gt;, where &lt;math&gt;n = |V|&lt;/math&gt; and &lt;math&gt;m = |E|&lt;/math&gt;. 
:(b) Give an &lt;math&gt;O(n + m)&lt;/math&gt; algorithm to test whether graph &lt;math&gt;G&lt;/math&gt; contains a mother vertex.
[[7.35|Solution]]


:7.36. Let &lt;math&gt;G&lt;/math&gt; be a directed graph. We say that &lt;math&gt;G&lt;/math&gt; is ''k-cyclic'' if every (not necessarily simple) cycle in &lt;math&gt;G&lt;/math&gt; contains at most &lt;math&gt;k&lt;/math&gt; distinct nodes. Give a linear-time algorithm to determine if a directed graph &lt;math&gt;G&lt;/math&gt; is &lt;math&gt;k&lt;/math&gt;-cyclic, where &lt;math&gt;G&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt; are given as inputs. Justify the correctness and running time of your algorithm.


:[[7.37]]. A ''tournament'' is a directed graph formed by taking the complete undirected graph and assigning arbitrary directions on the edges—that is, a graph &lt;math&gt;G = (V, E)&lt;/math&gt; such that for all &lt;math&gt;u,v \in V&lt;/math&gt;, exactly one of &lt;math&gt;(u, v)&lt;/math&gt; or &lt;math&gt;(v, u)&lt;/math&gt; is in &lt;math&gt;E&lt;/math&gt;. Show that every tournament has a Hamiltonian path—that is, a path that visits every vertex exactly once. Give an algorithm to find this path.
[[7.37|Solution]]

===Articulation Vertices===

:7.38. An articulation vertex of a connected graph &lt;math&gt;G&lt;/math&gt; is a vertex whose deletion disconnects &lt;math&gt;G&lt;/math&gt;. Let &lt;math&gt;G&lt;/math&gt; be a graph with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges. Give a simple &lt;math&gt;O(n+m)&lt;/math&gt; algorithm for finding a vertex of &lt;math&gt;G&lt;/math&gt; that is not an articulation vertex—that is, whose deletion does not disconnect &lt;math&gt;G&lt;/math&gt;.


:[[7.39]]. Following up on the previous problem, give an &lt;math&gt;O(n+m)&lt;/math&gt; algorithm that finds a deletion order for the &lt;math&gt;n&lt;/math&gt; vertices such that no deletion disconnects the graph. (Hint: think DFS/BFS.)
[[7.39|Solution]]


:7.40. Suppose &lt;math&gt;G&lt;/math&gt; is a connected undirected graph. An edge &lt;math&gt;e&lt;/math&gt; whose removal disconnects the graph is called a bridge. Must every bridge &lt;math&gt;e&lt;/math&gt; be an edge in a depth-first search tree of &lt;math&gt;G&lt;/math&gt;? Give a proof or a counterexample.


:[[7.41]]. A city that only has two-way streets has decided to change them all into one-way streets. They want to ensure that the new network is strongly connected so everyone can legally drive anywhere in the city and back.
:(a) Let &lt;math&gt;G&lt;/math&gt; be the original undirected graph. Prove that there is a way to properly orient/direct the edges of &lt;math&gt;G&lt;/math&gt; provided &lt;math&gt;G&lt;/math&gt; does not contain a bridge.
:(b) Give an efficient algorithm to orient the edges of a bridgeless graph &lt;math&gt;G&lt;/math&gt; so the result is strongly connected.
[[7.41|Solution]]

===Interview Problems===

:7.42. Which data structures are used in depth-first and breath-first search?


:[[7.43]]. Write a function to traverse binary search tree and return the ith node in sorted order.
[[7.43|Solution]]


Back to [[Chapter List]]</text>
      <sha1>kk4d1nws9snhb3bfemm3fubq646rzr3</sha1>
    </revision>
  </page>
  <page>
    <title>Chapter 8</title>
    <ns>0</ns>
    <id>11</id>
    <revision>
      <id>20</id>
      <timestamp>2020-08-23T19:35:22Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Problems   Back to [[Chapter List]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="35">Problems


Back to [[Chapter List]]</text>
      <sha1>95722ndl4ewzic1ak6z8g4auy0tqhc6</sha1>
    </revision>
    <revision>
      <id>118</id>
      <parentid>20</parentid>
      <timestamp>2020-09-07T18:57:07Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="473">=Weighted Graph Algorithms=

===Simulating graph Algorithms===

:[[8.1]]


===Minimum Spanning Tree===

:8.2


:[[8.3]]


:8.4


:[[8.5]]


:8.6


:[[8.7]]


:8.8


:[[8.9]]


:8.10


:[[8.11]]


:8.12


===Union Find===

:[[8.13]]


:8.14


===Shortest Paths===

:[[8:15]]


:8.16


:[[8.17]]


:8.18


:[[8.19]]


:8.20


:[[8.21]]


:8.22


:[[8.23]]


:8.24


:[[8.25]]


:8.26


:[[8.27]]


===Network Flow and Matching===

:8.28


:[[8.29]]


Back to [[Chapter List]]</text>
      <sha1>ncd381vrpm5rt4yiwcfnpwtzsjlfop7</sha1>
    </revision>
    <revision>
      <id>231</id>
      <parentid>118</parentid>
      <timestamp>2020-09-13T22:00:04Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Weighted Graph Algorithms */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="473">=Weighted Graph Algorithms=

===Simulating Graph Algorithms===

:[[8.1]]


===Minimum Spanning Tree===

:8.2


:[[8.3]]


:8.4


:[[8.5]]


:8.6


:[[8.7]]


:8.8


:[[8.9]]


:8.10


:[[8.11]]


:8.12


===Union Find===

:[[8.13]]


:8.14


===Shortest Paths===

:[[8:15]]


:8.16


:[[8.17]]


:8.18


:[[8.19]]


:8.20


:[[8.21]]


:8.22


:[[8.23]]


:8.24


:[[8.25]]


:8.26


:[[8.27]]


===Network Flow and Matching===

:8.28


:[[8.29]]


Back to [[Chapter List]]</text>
      <sha1>f601uyg0swznfj6q3tnwi39gfdzd4lg</sha1>
    </revision>
    <revision>
      <id>232</id>
      <parentid>231</parentid>
      <timestamp>2020-09-13T22:31:17Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Simulating Graph Algorithms */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="828">=Weighted Graph Algorithms=

===Simulating Graph Algorithms===

:[[8.1]]. For the graphs in Problem 7-1:
:(a) Draw the spanning forest after every iteration of the main loop in Kruskal’s algorithm.
:(b) Draw the spanning forest after every iteration of the main loop in Prim’s algorithm.
:(c) Find the shortest-path spanning tree rooted in &lt;math&gt;A&lt;/math&gt;.
:(d) Compute the maximum flow from &lt;math&gt;A&lt;/math&gt; to &lt;math&gt;H&lt;/math&gt;.

===Minimum Spanning Tree===

:8.2


:[[8.3]]


:8.4


:[[8.5]]


:8.6


:[[8.7]]


:8.8


:[[8.9]]


:8.10


:[[8.11]]


:8.12


===Union Find===

:[[8.13]]


:8.14


===Shortest Paths===

:[[8:15]]


:8.16


:[[8.17]]


:8.18


:[[8.19]]


:8.20


:[[8.21]]


:8.22


:[[8.23]]


:8.24


:[[8.25]]


:8.26


:[[8.27]]


===Network Flow and Matching===

:8.28


:[[8.29]]


Back to [[Chapter List]]</text>
      <sha1>ts2o7z2p2u52oszq7ta2d58z52zaemx</sha1>
    </revision>
    <revision>
      <id>233</id>
      <parentid>232</parentid>
      <timestamp>2020-09-13T22:31:33Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Simulating Graph Algorithms */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="845">=Weighted Graph Algorithms=

===Simulating Graph Algorithms===

:[[8.1]]. For the graphs in Problem 7-1:
:(a) Draw the spanning forest after every iteration of the main loop in Kruskal’s algorithm.
:(b) Draw the spanning forest after every iteration of the main loop in Prim’s algorithm.
:(c) Find the shortest-path spanning tree rooted in &lt;math&gt;A&lt;/math&gt;.
:(d) Compute the maximum flow from &lt;math&gt;A&lt;/math&gt; to &lt;math&gt;H&lt;/math&gt;.
[[8.1|Solution]]

===Minimum Spanning Tree===

:8.2


:[[8.3]]


:8.4


:[[8.5]]


:8.6


:[[8.7]]


:8.8


:[[8.9]]


:8.10


:[[8.11]]


:8.12


===Union Find===

:[[8.13]]


:8.14


===Shortest Paths===

:[[8:15]]


:8.16


:[[8.17]]


:8.18


:[[8.19]]


:8.20


:[[8.21]]


:8.22


:[[8.23]]


:8.24


:[[8.25]]


:8.26


:[[8.27]]


===Network Flow and Matching===

:8.28


:[[8.29]]


Back to [[Chapter List]]</text>
      <sha1>ax6xp12e5vxkaiakqpauv0dr8dkoxkj</sha1>
    </revision>
    <revision>
      <id>234</id>
      <parentid>233</parentid>
      <timestamp>2020-09-13T22:43:32Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Minimum Spanning Tree */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="3860">=Weighted Graph Algorithms=

===Simulating Graph Algorithms===

:[[8.1]]. For the graphs in Problem 7-1:
:(a) Draw the spanning forest after every iteration of the main loop in Kruskal’s algorithm.
:(b) Draw the spanning forest after every iteration of the main loop in Prim’s algorithm.
:(c) Find the shortest-path spanning tree rooted in &lt;math&gt;A&lt;/math&gt;.
:(d) Compute the maximum flow from &lt;math&gt;A&lt;/math&gt; to &lt;math&gt;H&lt;/math&gt;.
[[8.1|Solution]]

===Minimum Spanning Tree===

:8.2. Is the path between two vertices in a minimum spanning tree necessarily a shortest path between the two vertices in the full graph? Give a proof or a counterexample.


:[[8.3]]. Assume that all edges in the graph have distinct edge weights (i.e., no pair of edges have the same weight). Is the path between a pair of vertices in a minimum spanning tree necessarily a shortest path between the two vertices in the full graph? Give a proof or a counterexample.
[[8.3|Solution]]


:8.4. Can Prim’s and Kruskal’s algorithms yield different minimum spanning trees? Explain why or why not.


:[[8.5]]. Does either Prim’s or Kruskal’s algorithm work if there are negative edge weights? Explain why or why not.
[[8.5|Solution]]


:8.6. (a) Assume that all edges in the graph have distinct edge weights (i.e., no pair of edges have the same weight). Is the ''minimum spanning tree'' of this graph unique? Give a proof or a counterexample.
:(b) Again, assume that all edges in the graph have distinct edge weights (i.e. no pair of edges have the same weight). Is the ''shortest-path spanning tree'' of this graph unique? Give a proof or a counterexample.


:[[8.7]]. Suppose we are given the minimum spanning tree &lt;math&gt;T&lt;/math&gt; of a given graph &lt;math&gt;G&lt;/math&gt; (with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges) and a new edge &lt;math&gt;e = (u, v)&lt;/math&gt; of weight &lt;math&gt;w&lt;/math&gt; that we will add to &lt;math&gt;G&lt;/math&gt;. Give an efficient algorithm to find the minimum spanning tree of the graph &lt;math&gt;G + e&lt;/math&gt;. Your algorithm should run in &lt;math&gt;O(n)&lt;/math&gt; time to receive full credit.
[[8.7|Solution]]


:8.8. (a) Let &lt;math&gt;T&lt;/math&gt; be a minimum spanning tree of a weighted graph &lt;math&gt;G&lt;/math&gt;. Construct a new graph &lt;math&gt;G'&lt;/math&gt; by adding a weight of &lt;math&gt;k&lt;/math&gt; to every edge of &lt;math&gt;G&lt;/math&gt;. Do the edges of &lt;math&gt;T&lt;/math&gt; form a minimum spanning tree of &lt;math&gt;G'&lt;/math&gt;? Prove the statement or give a counterexample.
:(b) Let &lt;math&gt;P = {s, . . . , t}&lt;/math&gt; describe a shortest path between vertices &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt; of a weighted graph &lt;math&gt;G&lt;/math&gt;. Construct a new graph &lt;math&gt;G'&lt;/math&gt; by adding a weight of &lt;math&gt;k&lt;/math&gt; to every edge of &lt;math&gt;G&lt;/math&gt;. Does &lt;math&gt;P&lt;/math&gt; describe a shortest path from &lt;math&gt;s&lt;/math&gt; to &lt;math&gt;t&lt;/math&gt; in &lt;math&gt;G'&lt;/math&gt;? Prove the statement or give a counterexample.


:[[8.9]]. Devise and analyze an algorithm that takes a weighted graph &lt;math&gt;G&lt;/math&gt; and finds the smallest change in the cost to a non-minimum spanning tree edge that would cause a change in the minimum spanning tree of &lt;math&gt;G&lt;/math&gt;. Your algorithm must be correct and run in polynomial time.
[[8.9|Solution]]


:8.10. Consider the problem of finding a minimum-weight connected subset &lt;math&gt;T&lt;/math&gt; of edges from a weighted connected graph &lt;math&gt;G&lt;/math&gt;. The weight of &lt;math&gt;T&lt;/math&gt; is the sum of all the edge weights in &lt;math&gt;T&lt;/math&gt;.
:(a) Why is this problem not just the minimum spanning tree problem? (Hint: think negative weight edges.)
:(b) Give an efficient algorithm to compute the minimum-weight connected subset &lt;math&gt;T&lt;/math&gt;.


:[[8.11]]


:8.12

===Union Find===

:[[8.13]]


:8.14


===Shortest Paths===

:[[8:15]]


:8.16


:[[8.17]]


:8.18


:[[8.19]]


:8.20


:[[8.21]]


:8.22


:[[8.23]]


:8.24


:[[8.25]]


:8.26


:[[8.27]]


===Network Flow and Matching===

:8.28


:[[8.29]]


Back to [[Chapter List]]</text>
      <sha1>kpdyiinjapwgtufmumnt0mbnui4saq8</sha1>
    </revision>
    <revision>
      <id>235</id>
      <parentid>234</parentid>
      <timestamp>2020-09-13T23:01:04Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Minimum Spanning Tree */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="5102">=Weighted Graph Algorithms=

===Simulating Graph Algorithms===

:[[8.1]]. For the graphs in Problem 7-1:
:(a) Draw the spanning forest after every iteration of the main loop in Kruskal’s algorithm.
:(b) Draw the spanning forest after every iteration of the main loop in Prim’s algorithm.
:(c) Find the shortest-path spanning tree rooted in &lt;math&gt;A&lt;/math&gt;.
:(d) Compute the maximum flow from &lt;math&gt;A&lt;/math&gt; to &lt;math&gt;H&lt;/math&gt;.
[[8.1|Solution]]

===Minimum Spanning Tree===

:8.2. Is the path between two vertices in a minimum spanning tree necessarily a shortest path between the two vertices in the full graph? Give a proof or a counterexample.


:[[8.3]]. Assume that all edges in the graph have distinct edge weights (i.e., no pair of edges have the same weight). Is the path between a pair of vertices in a minimum spanning tree necessarily a shortest path between the two vertices in the full graph? Give a proof or a counterexample.
[[8.3|Solution]]


:8.4. Can Prim’s and Kruskal’s algorithms yield different minimum spanning trees? Explain why or why not.


:[[8.5]]. Does either Prim’s or Kruskal’s algorithm work if there are negative edge weights? Explain why or why not.
[[8.5|Solution]]


:8.6. (a) Assume that all edges in the graph have distinct edge weights (i.e., no pair of edges have the same weight). Is the ''minimum spanning tree'' of this graph unique? Give a proof or a counterexample.
:(b) Again, assume that all edges in the graph have distinct edge weights (i.e. no pair of edges have the same weight). Is the ''shortest-path spanning tree'' of this graph unique? Give a proof or a counterexample.


:[[8.7]]. Suppose we are given the minimum spanning tree &lt;math&gt;T&lt;/math&gt; of a given graph &lt;math&gt;G&lt;/math&gt; (with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges) and a new edge &lt;math&gt;e = (u, v)&lt;/math&gt; of weight &lt;math&gt;w&lt;/math&gt; that we will add to &lt;math&gt;G&lt;/math&gt;. Give an efficient algorithm to find the minimum spanning tree of the graph &lt;math&gt;G + e&lt;/math&gt;. Your algorithm should run in &lt;math&gt;O(n)&lt;/math&gt; time to receive full credit.
[[8.7|Solution]]


:8.8. (a) Let &lt;math&gt;T&lt;/math&gt; be a minimum spanning tree of a weighted graph &lt;math&gt;G&lt;/math&gt;. Construct a new graph &lt;math&gt;G'&lt;/math&gt; by adding a weight of &lt;math&gt;k&lt;/math&gt; to every edge of &lt;math&gt;G&lt;/math&gt;. Do the edges of &lt;math&gt;T&lt;/math&gt; form a minimum spanning tree of &lt;math&gt;G'&lt;/math&gt;? Prove the statement or give a counterexample.
:(b) Let &lt;math&gt;P = {s, . . . , t}&lt;/math&gt; describe a shortest path between vertices &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt; of a weighted graph &lt;math&gt;G&lt;/math&gt;. Construct a new graph &lt;math&gt;G'&lt;/math&gt; by adding a weight of &lt;math&gt;k&lt;/math&gt; to every edge of &lt;math&gt;G&lt;/math&gt;. Does &lt;math&gt;P&lt;/math&gt; describe a shortest path from &lt;math&gt;s&lt;/math&gt; to &lt;math&gt;t&lt;/math&gt; in &lt;math&gt;G'&lt;/math&gt;? Prove the statement or give a counterexample.


:[[8.9]]. Devise and analyze an algorithm that takes a weighted graph &lt;math&gt;G&lt;/math&gt; and finds the smallest change in the cost to a non-minimum spanning tree edge that would cause a change in the minimum spanning tree of &lt;math&gt;G&lt;/math&gt;. Your algorithm must be correct and run in polynomial time.
[[8.9|Solution]]


:8.10. Consider the problem of finding a minimum-weight connected subset &lt;math&gt;T&lt;/math&gt; of edges from a weighted connected graph &lt;math&gt;G&lt;/math&gt;. The weight of &lt;math&gt;T&lt;/math&gt; is the sum of all the edge weights in &lt;math&gt;T&lt;/math&gt;.
:(a) Why is this problem not just the minimum spanning tree problem? (Hint: think negative weight edges.)
:(b) Give an efficient algorithm to compute the minimum-weight connected subset &lt;math&gt;T&lt;/math&gt;.


:[[8.11]]. Let &lt;math&gt;T = (V, E')&lt;/math&gt; be a minimum spanning tree of a given graph &lt;math&gt;G = (V, E)&lt;/math&gt; with positive edge weights. Now suppose the weight of a particular edge &lt;math&gt;e \in E&lt;/math&gt; is modified from &lt;math&gt;w(e)&lt;/math&gt; to a new value &lt;math&gt;\hat{w}(e)&lt;/math&gt;. We seek to update the minimum spanning tree &lt;math&gt;T&lt;/math&gt; to reflect this change without recomputing the entire tree from scratch. For each of the following four cases, give a linear-time algorithm to update the tree:
:(a)&lt;math&gt;e \notin E'&lt;/math&gt; and &lt;math&gt; \hat{w}(e) &gt; w(e)&lt;/math&gt;
:(b) &lt;math&gt;e \notin E'&lt;/math&gt; and &lt;math&gt;\hat{w}(e) &lt; w(e)&lt;/math&gt;
:(c) &lt;math&gt;e \in E'&lt;/math&gt; and &lt;math&gt;\hat{w}(e) &lt; w(e)&lt;/math&gt;
:(d) &lt;math&gt;e \in E' &lt;/math&gt; and &lt;math&gt;\hat{w}(e) &gt; w(e)&lt;/math&gt;
[[8.11|Solution]]


:8.12. Let &lt;math&gt;G=(V,E)&lt;/math&gt; be an undirected graph. A set &lt;math&gt;F \subseteq E&lt;/math&gt; of edges is called a ''feedback-edge set'' if every cycle of &lt;math&gt;G&lt;/math&gt; has at least one edge in &lt;math&gt;F&lt;/math&gt;.
:(a)Suppose that &lt;math&gt;G&lt;/math&gt; is unweighted. Design an efficient algorithm to find a minimum-size feedback-edge set.
:(b)Suppose that &lt;math&gt;G&lt;/math&gt; is a weighted undirected graph with positive edge weights. Design an efficient algorithm to find a minimum-weight feedback-edge set.

===Union Find===

:[[8.13]]


:8.14


===Shortest Paths===

:[[8:15]]


:8.16


:[[8.17]]


:8.18


:[[8.19]]


:8.20


:[[8.21]]


:8.22


:[[8.23]]


:8.24


:[[8.25]]


:8.26


:[[8.27]]


===Network Flow and Matching===

:8.28


:[[8.29]]


Back to [[Chapter List]]</text>
      <sha1>qw6w70fqddoa84zcb92fcyg3u7g46zj</sha1>
    </revision>
    <revision>
      <id>236</id>
      <parentid>235</parentid>
      <timestamp>2020-09-13T23:04:29Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Union Find */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="5638">=Weighted Graph Algorithms=

===Simulating Graph Algorithms===

:[[8.1]]. For the graphs in Problem 7-1:
:(a) Draw the spanning forest after every iteration of the main loop in Kruskal’s algorithm.
:(b) Draw the spanning forest after every iteration of the main loop in Prim’s algorithm.
:(c) Find the shortest-path spanning tree rooted in &lt;math&gt;A&lt;/math&gt;.
:(d) Compute the maximum flow from &lt;math&gt;A&lt;/math&gt; to &lt;math&gt;H&lt;/math&gt;.
[[8.1|Solution]]

===Minimum Spanning Tree===

:8.2. Is the path between two vertices in a minimum spanning tree necessarily a shortest path between the two vertices in the full graph? Give a proof or a counterexample.


:[[8.3]]. Assume that all edges in the graph have distinct edge weights (i.e., no pair of edges have the same weight). Is the path between a pair of vertices in a minimum spanning tree necessarily a shortest path between the two vertices in the full graph? Give a proof or a counterexample.
[[8.3|Solution]]


:8.4. Can Prim’s and Kruskal’s algorithms yield different minimum spanning trees? Explain why or why not.


:[[8.5]]. Does either Prim’s or Kruskal’s algorithm work if there are negative edge weights? Explain why or why not.
[[8.5|Solution]]


:8.6. (a) Assume that all edges in the graph have distinct edge weights (i.e., no pair of edges have the same weight). Is the ''minimum spanning tree'' of this graph unique? Give a proof or a counterexample.
:(b) Again, assume that all edges in the graph have distinct edge weights (i.e. no pair of edges have the same weight). Is the ''shortest-path spanning tree'' of this graph unique? Give a proof or a counterexample.


:[[8.7]]. Suppose we are given the minimum spanning tree &lt;math&gt;T&lt;/math&gt; of a given graph &lt;math&gt;G&lt;/math&gt; (with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges) and a new edge &lt;math&gt;e = (u, v)&lt;/math&gt; of weight &lt;math&gt;w&lt;/math&gt; that we will add to &lt;math&gt;G&lt;/math&gt;. Give an efficient algorithm to find the minimum spanning tree of the graph &lt;math&gt;G + e&lt;/math&gt;. Your algorithm should run in &lt;math&gt;O(n)&lt;/math&gt; time to receive full credit.
[[8.7|Solution]]


:8.8. (a) Let &lt;math&gt;T&lt;/math&gt; be a minimum spanning tree of a weighted graph &lt;math&gt;G&lt;/math&gt;. Construct a new graph &lt;math&gt;G'&lt;/math&gt; by adding a weight of &lt;math&gt;k&lt;/math&gt; to every edge of &lt;math&gt;G&lt;/math&gt;. Do the edges of &lt;math&gt;T&lt;/math&gt; form a minimum spanning tree of &lt;math&gt;G'&lt;/math&gt;? Prove the statement or give a counterexample.
:(b) Let &lt;math&gt;P = {s, . . . , t}&lt;/math&gt; describe a shortest path between vertices &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt; of a weighted graph &lt;math&gt;G&lt;/math&gt;. Construct a new graph &lt;math&gt;G'&lt;/math&gt; by adding a weight of &lt;math&gt;k&lt;/math&gt; to every edge of &lt;math&gt;G&lt;/math&gt;. Does &lt;math&gt;P&lt;/math&gt; describe a shortest path from &lt;math&gt;s&lt;/math&gt; to &lt;math&gt;t&lt;/math&gt; in &lt;math&gt;G'&lt;/math&gt;? Prove the statement or give a counterexample.


:[[8.9]]. Devise and analyze an algorithm that takes a weighted graph &lt;math&gt;G&lt;/math&gt; and finds the smallest change in the cost to a non-minimum spanning tree edge that would cause a change in the minimum spanning tree of &lt;math&gt;G&lt;/math&gt;. Your algorithm must be correct and run in polynomial time.
[[8.9|Solution]]


:8.10. Consider the problem of finding a minimum-weight connected subset &lt;math&gt;T&lt;/math&gt; of edges from a weighted connected graph &lt;math&gt;G&lt;/math&gt;. The weight of &lt;math&gt;T&lt;/math&gt; is the sum of all the edge weights in &lt;math&gt;T&lt;/math&gt;.
:(a) Why is this problem not just the minimum spanning tree problem? (Hint: think negative weight edges.)
:(b) Give an efficient algorithm to compute the minimum-weight connected subset &lt;math&gt;T&lt;/math&gt;.


:[[8.11]]. Let &lt;math&gt;T = (V, E')&lt;/math&gt; be a minimum spanning tree of a given graph &lt;math&gt;G = (V, E)&lt;/math&gt; with positive edge weights. Now suppose the weight of a particular edge &lt;math&gt;e \in E&lt;/math&gt; is modified from &lt;math&gt;w(e)&lt;/math&gt; to a new value &lt;math&gt;\hat{w}(e)&lt;/math&gt;. We seek to update the minimum spanning tree &lt;math&gt;T&lt;/math&gt; to reflect this change without recomputing the entire tree from scratch. For each of the following four cases, give a linear-time algorithm to update the tree:
:(a)&lt;math&gt;e \notin E'&lt;/math&gt; and &lt;math&gt; \hat{w}(e) &gt; w(e)&lt;/math&gt;
:(b) &lt;math&gt;e \notin E'&lt;/math&gt; and &lt;math&gt;\hat{w}(e) &lt; w(e)&lt;/math&gt;
:(c) &lt;math&gt;e \in E'&lt;/math&gt; and &lt;math&gt;\hat{w}(e) &lt; w(e)&lt;/math&gt;
:(d) &lt;math&gt;e \in E' &lt;/math&gt; and &lt;math&gt;\hat{w}(e) &gt; w(e)&lt;/math&gt;
[[8.11|Solution]]


:8.12. Let &lt;math&gt;G=(V,E)&lt;/math&gt; be an undirected graph. A set &lt;math&gt;F \subseteq E&lt;/math&gt; of edges is called a ''feedback-edge set'' if every cycle of &lt;math&gt;G&lt;/math&gt; has at least one edge in &lt;math&gt;F&lt;/math&gt;.
:(a)Suppose that &lt;math&gt;G&lt;/math&gt; is unweighted. Design an efficient algorithm to find a minimum-size feedback-edge set.
:(b)Suppose that &lt;math&gt;G&lt;/math&gt; is a weighted undirected graph with positive edge weights. Design an efficient algorithm to find a minimum-weight feedback-edge set.

===Union Find===

:[[8.13]]. Devise an efficient data structure to handle the following operations on a weighted directed graph:
:(a)Merge two given components.
:(b)Locate which component contains a given vertex &lt;math&gt;v&lt;/math&gt;.
:(c)Retrieve a minimum edge from a given component.
[[8.13|Solution]]


:8.14. Design a data structure that can perform a sequence of, &lt;math&gt;m&lt;/math&gt; ''union'' and  ''find'' operations on a universal set of &lt;math&gt;n&lt;/math&gt; elements, consisting of a sequence of all ''unions'' followed by a sequence of all ''finds'', in time &lt;math&gt;O(m+n)&lt;/math&gt;.

===Shortest Paths===

:[[8:15]]


:8.16


:[[8.17]]


:8.18


:[[8.19]]


:8.20


:[[8.21]]


:8.22


:[[8.23]]


:8.24


:[[8.25]]


:8.26


:[[8.27]]


===Network Flow and Matching===

:8.28


:[[8.29]]


Back to [[Chapter List]]</text>
      <sha1>c0vciais8ilkoaf02lv1ryodiv6p1n1</sha1>
    </revision>
    <revision>
      <id>237</id>
      <parentid>236</parentid>
      <timestamp>2020-09-13T23:31:33Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Shortest Paths */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="11499">=Weighted Graph Algorithms=

===Simulating Graph Algorithms===

:[[8.1]]. For the graphs in Problem 7-1:
:(a) Draw the spanning forest after every iteration of the main loop in Kruskal’s algorithm.
:(b) Draw the spanning forest after every iteration of the main loop in Prim’s algorithm.
:(c) Find the shortest-path spanning tree rooted in &lt;math&gt;A&lt;/math&gt;.
:(d) Compute the maximum flow from &lt;math&gt;A&lt;/math&gt; to &lt;math&gt;H&lt;/math&gt;.
[[8.1|Solution]]

===Minimum Spanning Tree===

:8.2. Is the path between two vertices in a minimum spanning tree necessarily a shortest path between the two vertices in the full graph? Give a proof or a counterexample.


:[[8.3]]. Assume that all edges in the graph have distinct edge weights (i.e., no pair of edges have the same weight). Is the path between a pair of vertices in a minimum spanning tree necessarily a shortest path between the two vertices in the full graph? Give a proof or a counterexample.
[[8.3|Solution]]


:8.4. Can Prim’s and Kruskal’s algorithms yield different minimum spanning trees? Explain why or why not.


:[[8.5]]. Does either Prim’s or Kruskal’s algorithm work if there are negative edge weights? Explain why or why not.
[[8.5|Solution]]


:8.6. (a) Assume that all edges in the graph have distinct edge weights (i.e., no pair of edges have the same weight). Is the ''minimum spanning tree'' of this graph unique? Give a proof or a counterexample.
:(b) Again, assume that all edges in the graph have distinct edge weights (i.e. no pair of edges have the same weight). Is the ''shortest-path spanning tree'' of this graph unique? Give a proof or a counterexample.


:[[8.7]]. Suppose we are given the minimum spanning tree &lt;math&gt;T&lt;/math&gt; of a given graph &lt;math&gt;G&lt;/math&gt; (with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges) and a new edge &lt;math&gt;e = (u, v)&lt;/math&gt; of weight &lt;math&gt;w&lt;/math&gt; that we will add to &lt;math&gt;G&lt;/math&gt;. Give an efficient algorithm to find the minimum spanning tree of the graph &lt;math&gt;G + e&lt;/math&gt;. Your algorithm should run in &lt;math&gt;O(n)&lt;/math&gt; time to receive full credit.
[[8.7|Solution]]


:8.8. (a) Let &lt;math&gt;T&lt;/math&gt; be a minimum spanning tree of a weighted graph &lt;math&gt;G&lt;/math&gt;. Construct a new graph &lt;math&gt;G'&lt;/math&gt; by adding a weight of &lt;math&gt;k&lt;/math&gt; to every edge of &lt;math&gt;G&lt;/math&gt;. Do the edges of &lt;math&gt;T&lt;/math&gt; form a minimum spanning tree of &lt;math&gt;G'&lt;/math&gt;? Prove the statement or give a counterexample.
:(b) Let &lt;math&gt;P = {s, . . . , t}&lt;/math&gt; describe a shortest path between vertices &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt; of a weighted graph &lt;math&gt;G&lt;/math&gt;. Construct a new graph &lt;math&gt;G'&lt;/math&gt; by adding a weight of &lt;math&gt;k&lt;/math&gt; to every edge of &lt;math&gt;G&lt;/math&gt;. Does &lt;math&gt;P&lt;/math&gt; describe a shortest path from &lt;math&gt;s&lt;/math&gt; to &lt;math&gt;t&lt;/math&gt; in &lt;math&gt;G'&lt;/math&gt;? Prove the statement or give a counterexample.


:[[8.9]]. Devise and analyze an algorithm that takes a weighted graph &lt;math&gt;G&lt;/math&gt; and finds the smallest change in the cost to a non-minimum spanning tree edge that would cause a change in the minimum spanning tree of &lt;math&gt;G&lt;/math&gt;. Your algorithm must be correct and run in polynomial time.
[[8.9|Solution]]


:8.10. Consider the problem of finding a minimum-weight connected subset &lt;math&gt;T&lt;/math&gt; of edges from a weighted connected graph &lt;math&gt;G&lt;/math&gt;. The weight of &lt;math&gt;T&lt;/math&gt; is the sum of all the edge weights in &lt;math&gt;T&lt;/math&gt;.
:(a) Why is this problem not just the minimum spanning tree problem? (Hint: think negative weight edges.)
:(b) Give an efficient algorithm to compute the minimum-weight connected subset &lt;math&gt;T&lt;/math&gt;.


:[[8.11]]. Let &lt;math&gt;T = (V, E')&lt;/math&gt; be a minimum spanning tree of a given graph &lt;math&gt;G = (V, E)&lt;/math&gt; with positive edge weights. Now suppose the weight of a particular edge &lt;math&gt;e \in E&lt;/math&gt; is modified from &lt;math&gt;w(e)&lt;/math&gt; to a new value &lt;math&gt;\hat{w}(e)&lt;/math&gt;. We seek to update the minimum spanning tree &lt;math&gt;T&lt;/math&gt; to reflect this change without recomputing the entire tree from scratch. For each of the following four cases, give a linear-time algorithm to update the tree:
:(a)&lt;math&gt;e \notin E'&lt;/math&gt; and &lt;math&gt; \hat{w}(e) &gt; w(e)&lt;/math&gt;
:(b) &lt;math&gt;e \notin E'&lt;/math&gt; and &lt;math&gt;\hat{w}(e) &lt; w(e)&lt;/math&gt;
:(c) &lt;math&gt;e \in E'&lt;/math&gt; and &lt;math&gt;\hat{w}(e) &lt; w(e)&lt;/math&gt;
:(d) &lt;math&gt;e \in E' &lt;/math&gt; and &lt;math&gt;\hat{w}(e) &gt; w(e)&lt;/math&gt;
[[8.11|Solution]]


:8.12. Let &lt;math&gt;G=(V,E)&lt;/math&gt; be an undirected graph. A set &lt;math&gt;F \subseteq E&lt;/math&gt; of edges is called a ''feedback-edge set'' if every cycle of &lt;math&gt;G&lt;/math&gt; has at least one edge in &lt;math&gt;F&lt;/math&gt;.
:(a)Suppose that &lt;math&gt;G&lt;/math&gt; is unweighted. Design an efficient algorithm to find a minimum-size feedback-edge set.
:(b)Suppose that &lt;math&gt;G&lt;/math&gt; is a weighted undirected graph with positive edge weights. Design an efficient algorithm to find a minimum-weight feedback-edge set.

===Union Find===

:[[8.13]]. Devise an efficient data structure to handle the following operations on a weighted directed graph:
:(a)Merge two given components.
:(b)Locate which component contains a given vertex &lt;math&gt;v&lt;/math&gt;.
:(c)Retrieve a minimum edge from a given component.
[[8.13|Solution]]


:8.14. Design a data structure that can perform a sequence of, &lt;math&gt;m&lt;/math&gt; ''union'' and  ''find'' operations on a universal set of &lt;math&gt;n&lt;/math&gt; elements, consisting of a sequence of all ''unions'' followed by a sequence of all ''finds'', in time &lt;math&gt;O(m+n)&lt;/math&gt;.

===Shortest Paths===

:[[8:15]]. The ''single-destination shortest path'' problem for a directed graph seeks the shortest path ''from'' every vertex to a specified vertex &lt;math&gt;v&lt;/math&gt;. Give an efficient algorithm to solve the single-destination shortest paths problem.
[[8.15|Solution]]


:8.16. Let &lt;math&gt;G=(V,E)&lt;/math&gt; be an undirected weighted graph, and let &lt;math&gt;T&lt;/math&gt; be the shortest-path spanning tree rooted at a vertex &lt;math&gt;v&lt;/math&gt;. Suppose now that all the edge weights in &lt;math&gt;G&lt;/math&gt; are increased by a constant number &lt;math&gt;k&lt;/math&gt;. Is &lt;math&gt;T&lt;/math&gt; still the shortest-path spanning tree from &lt;math&gt;v&lt;/math&gt;?


:[[8.17]]. (a)Give an example of a weighted connected graph &lt;math&gt;G=(V,E)&lt;/math&gt; and a vertex &lt;math&gt;v&lt;/math&gt;, such that the minimum spanning tree of &lt;math&gt;G&lt;/math&gt; is the same as the shortest-path spanning tree rooted at &lt;math&gt;v&lt;/math&gt;.
:(b)Give an example of a weighted connected directed graph &lt;math&gt;G=(V,E)&lt;/math&gt; and a vertex &lt;math&gt;v&lt;/math&gt;, such that the minimum-cost spanning tree of &lt;math&gt;G&lt;/math&gt; is very different from the shortest-path spanning tree rooted at &lt;math&gt;v&lt;/math&gt;.
:(c)Can the two trees be completely disjointed?
[[8.17|Solution]]


:8.18. Either prove the following or give a counterexample:
:(a)Is the path between a pair of vertices in a minimum spanning tree of an undirected graph necessarily the shortest (minimum weight) path?
:(b)Suppose that the minimum spanning tree of the graph is unique. Is the path between a pair of vertices in a minimum spanning tree of an undirected graph necessarily the shortest (minimum weight) path?


:[[8.19]]. Give an efficient algorithm to find the shortest path from &lt;math&gt;x&lt;/math&gt; to &lt;math&gt;y&lt;/math&gt; in an undirected weighted graph &lt;math&gt;G = (V, E)&lt;/math&gt; with positive edge weights, subject to the constraint that this path must pass through a particular vertex &lt;math&gt;z&lt;/math&gt;.


:8.20. In certain graph problems, vertices have can have weights instead of or in addition to the weights of edges. Let &lt;math&gt;C_v&lt;/math&gt; be the cost of vertex &lt;math&gt;v&lt;/math&gt;, and &lt;math&gt;C_{(x,y)}&lt;/math&gt; the cost of the edge &lt;math&gt;(x,y)&lt;/math&gt;. This problem is concerned with finding the cheapest path between vertices &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; in a graph &lt;math&gt;G&lt;/math&gt;. The cost of a path is the sum of the costs of the edges and vertices encountered on the path.
:(a)Suppose that each edge in the graph has a weight of zero (while non-edges have a cost of &lt;math&gt;\infty&lt;/math&gt;). Assume that &lt;math&gt;C_v = 1&lt;/math&gt; for all vertices &lt;math&gt;1 \leq v \leq n&lt;/math&gt; (i.e., all vertices have the same cost). Give an ''efficient'' algorithm to find the cheapest path from &lt;math&gt;a&lt;/math&gt; to &lt;math&gt;b&lt;/math&gt; and its time complexity.
:(b)Now suppose that the vertex costs are not constant (but are all positive) and the edge costs remain as above. Give an ''efficient'' algorithm to find the cheapest path from &lt;math&gt;a&lt;/math&gt; to &lt;math&gt;b&lt;/math&gt; and its time complexity.
:(c)Now suppose that both the edge and vertex costs are not constant (but are all positive). Give an ''efficient'' algorithm to find the cheapest path from &lt;math&gt;a&lt;/math&gt; to &lt;math&gt;b&lt;/math&gt; and its time complexity.


:[[8.21]]. Give an &lt;math&gt;O(n^3)&lt;/math&gt; algorithm that takes an &lt;math&gt;n&lt;/math&gt;-vertex directed graph &lt;math&gt;G&lt;/math&gt; with positive edge lengths, and returns the length of the shortest cycle in the graph. This length is &lt;math&gt;\infty&lt;/math&gt; in the case of an acyclic graph.
[[8.21|Solution]]


:8.22. A highway network is represented by a weighted graph &lt;math&gt;G&lt;/math&gt;, with edges corresponding to roads and vertices corresponding to road intersections. Each road is labeled with the maximum possible height of vehicles that can pass through the road. Give an efficient algorithm to compute the maximum possible height of vehicles that can successfully travel from &lt;math&gt;s&lt;/math&gt; to &lt;math&gt;t&lt;/math&gt;. What is the runtime of your algorithm?


:[[8.23]]. You are given a directed graph &lt;math&gt;G&lt;/math&gt; with possibly negative weighted edges, in which the shortest path between any two vertices is guaranteed to have at most &lt;math&gt;k&lt;/math&gt; edges. Give an algorithm that finds the shortest path between two vertices &lt;math&gt;u&lt;/math&gt; and &lt;math&gt;v&lt;/math&gt; in &lt;math&gt;O(k * (n + m))&lt;/math&gt; time.
[[8.23|Solution]]


:8.24. Can we solve the single-source ''longest''-path problem by changing ''minimum'' to ''maximum'' in Dijkstra’s algorithm? If so, then prove your algorithm correct. If not, then provide a counterexample.


:[[8.25]]. Let &lt;math&gt;G = (V, E)&lt;/math&gt; be a weighted acyclic directed graph with possibly negative edge weights. Design a linear-time algorithm to solve the single-source shortest-path problem from a given source &lt;math&gt;v&lt;/math&gt;.
[[8.25|Solution]]


:8.26. Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a directed weighted graph such that all the weights are positive. Let &lt;math&gt;v&lt;/math&gt; and &lt;math&gt;w&lt;/math&gt; be two vertices in &lt;math&gt;G&lt;/math&gt; and &lt;math&gt;k \leq |V|&lt;/math&gt; be an integer. Design an algorithm to find the shortest path from &lt;math&gt;v&lt;/math&gt; to &lt;math&gt;w&lt;/math&gt; that contains exactly &lt;math&gt;k&lt;/math&gt; edges. Note that the path need not be simple.


:[[8.27]].''Arbitrage'' is the use of discrepancies in currency-exchange rates to make a profit. For example, there may be a small window of time during which 1 U.S. dollar buys 0.75 British pounds, 1 British pound buys 2 Australian dollars, and 1 Australian dollar buys 0.70 U.S. dollars. At such a time, a smart trader can trade one U.S. dollar and end up with &lt;math&gt;0.75 \times 2 \times 0.7 = 1.05&lt;/math&gt; U.S. dollars---a profit of 5%. Suppose that there are &lt;math&gt;n&lt;/math&gt; currencies &lt;math&gt;c_1,...,c_n&lt;/math&gt; and an &lt;math&gt;n \times n&lt;/math&gt; table &lt;math&gt;R&lt;/math&gt; of exchange rates, such that one unit of currency &lt;math&gt;c_i&lt;/math&gt; buys &lt;math&gt;R[i,j]&lt;/math&gt; units of currency &lt;math&gt;c_j&lt;/math&gt;. Devise and analyze an algorithm to determine the maximum value of &lt;math&gt; R[c_1,c_{i1}] \cdot R[c_{i1},c_{i2}] \cdots R[c_{i{k-1}},c_{ik}] \cdot R[c_{ik},c_1] &lt;/math&gt; Hint: think all-pairs shortest path.
[[8.27|Solution]]

===Network Flow and Matching===

:8.28


:[[8.29]]


Back to [[Chapter List]]</text>
      <sha1>3dwn8lwvowqrzxq8usmpag3hg3u7a8y</sha1>
    </revision>
    <revision>
      <id>238</id>
      <parentid>237</parentid>
      <timestamp>2020-09-14T15:16:20Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Network Flow and Matching */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="11951">=Weighted Graph Algorithms=

===Simulating Graph Algorithms===

:[[8.1]]. For the graphs in Problem 7-1:
:(a) Draw the spanning forest after every iteration of the main loop in Kruskal’s algorithm.
:(b) Draw the spanning forest after every iteration of the main loop in Prim’s algorithm.
:(c) Find the shortest-path spanning tree rooted in &lt;math&gt;A&lt;/math&gt;.
:(d) Compute the maximum flow from &lt;math&gt;A&lt;/math&gt; to &lt;math&gt;H&lt;/math&gt;.
[[8.1|Solution]]

===Minimum Spanning Tree===

:8.2. Is the path between two vertices in a minimum spanning tree necessarily a shortest path between the two vertices in the full graph? Give a proof or a counterexample.


:[[8.3]]. Assume that all edges in the graph have distinct edge weights (i.e., no pair of edges have the same weight). Is the path between a pair of vertices in a minimum spanning tree necessarily a shortest path between the two vertices in the full graph? Give a proof or a counterexample.
[[8.3|Solution]]


:8.4. Can Prim’s and Kruskal’s algorithms yield different minimum spanning trees? Explain why or why not.


:[[8.5]]. Does either Prim’s or Kruskal’s algorithm work if there are negative edge weights? Explain why or why not.
[[8.5|Solution]]


:8.6. (a) Assume that all edges in the graph have distinct edge weights (i.e., no pair of edges have the same weight). Is the ''minimum spanning tree'' of this graph unique? Give a proof or a counterexample.
:(b) Again, assume that all edges in the graph have distinct edge weights (i.e. no pair of edges have the same weight). Is the ''shortest-path spanning tree'' of this graph unique? Give a proof or a counterexample.


:[[8.7]]. Suppose we are given the minimum spanning tree &lt;math&gt;T&lt;/math&gt; of a given graph &lt;math&gt;G&lt;/math&gt; (with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges) and a new edge &lt;math&gt;e = (u, v)&lt;/math&gt; of weight &lt;math&gt;w&lt;/math&gt; that we will add to &lt;math&gt;G&lt;/math&gt;. Give an efficient algorithm to find the minimum spanning tree of the graph &lt;math&gt;G + e&lt;/math&gt;. Your algorithm should run in &lt;math&gt;O(n)&lt;/math&gt; time to receive full credit.
[[8.7|Solution]]


:8.8. (a) Let &lt;math&gt;T&lt;/math&gt; be a minimum spanning tree of a weighted graph &lt;math&gt;G&lt;/math&gt;. Construct a new graph &lt;math&gt;G'&lt;/math&gt; by adding a weight of &lt;math&gt;k&lt;/math&gt; to every edge of &lt;math&gt;G&lt;/math&gt;. Do the edges of &lt;math&gt;T&lt;/math&gt; form a minimum spanning tree of &lt;math&gt;G'&lt;/math&gt;? Prove the statement or give a counterexample.
:(b) Let &lt;math&gt;P = {s, . . . , t}&lt;/math&gt; describe a shortest path between vertices &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt; of a weighted graph &lt;math&gt;G&lt;/math&gt;. Construct a new graph &lt;math&gt;G'&lt;/math&gt; by adding a weight of &lt;math&gt;k&lt;/math&gt; to every edge of &lt;math&gt;G&lt;/math&gt;. Does &lt;math&gt;P&lt;/math&gt; describe a shortest path from &lt;math&gt;s&lt;/math&gt; to &lt;math&gt;t&lt;/math&gt; in &lt;math&gt;G'&lt;/math&gt;? Prove the statement or give a counterexample.


:[[8.9]]. Devise and analyze an algorithm that takes a weighted graph &lt;math&gt;G&lt;/math&gt; and finds the smallest change in the cost to a non-minimum spanning tree edge that would cause a change in the minimum spanning tree of &lt;math&gt;G&lt;/math&gt;. Your algorithm must be correct and run in polynomial time.
[[8.9|Solution]]


:8.10. Consider the problem of finding a minimum-weight connected subset &lt;math&gt;T&lt;/math&gt; of edges from a weighted connected graph &lt;math&gt;G&lt;/math&gt;. The weight of &lt;math&gt;T&lt;/math&gt; is the sum of all the edge weights in &lt;math&gt;T&lt;/math&gt;.
:(a) Why is this problem not just the minimum spanning tree problem? (Hint: think negative weight edges.)
:(b) Give an efficient algorithm to compute the minimum-weight connected subset &lt;math&gt;T&lt;/math&gt;.


:[[8.11]]. Let &lt;math&gt;T = (V, E')&lt;/math&gt; be a minimum spanning tree of a given graph &lt;math&gt;G = (V, E)&lt;/math&gt; with positive edge weights. Now suppose the weight of a particular edge &lt;math&gt;e \in E&lt;/math&gt; is modified from &lt;math&gt;w(e)&lt;/math&gt; to a new value &lt;math&gt;\hat{w}(e)&lt;/math&gt;. We seek to update the minimum spanning tree &lt;math&gt;T&lt;/math&gt; to reflect this change without recomputing the entire tree from scratch. For each of the following four cases, give a linear-time algorithm to update the tree:
:(a)&lt;math&gt;e \notin E'&lt;/math&gt; and &lt;math&gt; \hat{w}(e) &gt; w(e)&lt;/math&gt;
:(b) &lt;math&gt;e \notin E'&lt;/math&gt; and &lt;math&gt;\hat{w}(e) &lt; w(e)&lt;/math&gt;
:(c) &lt;math&gt;e \in E'&lt;/math&gt; and &lt;math&gt;\hat{w}(e) &lt; w(e)&lt;/math&gt;
:(d) &lt;math&gt;e \in E' &lt;/math&gt; and &lt;math&gt;\hat{w}(e) &gt; w(e)&lt;/math&gt;
[[8.11|Solution]]


:8.12. Let &lt;math&gt;G=(V,E)&lt;/math&gt; be an undirected graph. A set &lt;math&gt;F \subseteq E&lt;/math&gt; of edges is called a ''feedback-edge set'' if every cycle of &lt;math&gt;G&lt;/math&gt; has at least one edge in &lt;math&gt;F&lt;/math&gt;.
:(a)Suppose that &lt;math&gt;G&lt;/math&gt; is unweighted. Design an efficient algorithm to find a minimum-size feedback-edge set.
:(b)Suppose that &lt;math&gt;G&lt;/math&gt; is a weighted undirected graph with positive edge weights. Design an efficient algorithm to find a minimum-weight feedback-edge set.

===Union Find===

:[[8.13]]. Devise an efficient data structure to handle the following operations on a weighted directed graph:
:(a)Merge two given components.
:(b)Locate which component contains a given vertex &lt;math&gt;v&lt;/math&gt;.
:(c)Retrieve a minimum edge from a given component.
[[8.13|Solution]]


:8.14. Design a data structure that can perform a sequence of, &lt;math&gt;m&lt;/math&gt; ''union'' and  ''find'' operations on a universal set of &lt;math&gt;n&lt;/math&gt; elements, consisting of a sequence of all ''unions'' followed by a sequence of all ''finds'', in time &lt;math&gt;O(m+n)&lt;/math&gt;.

===Shortest Paths===

:[[8:15]]. The ''single-destination shortest path'' problem for a directed graph seeks the shortest path ''from'' every vertex to a specified vertex &lt;math&gt;v&lt;/math&gt;. Give an efficient algorithm to solve the single-destination shortest paths problem.
[[8.15|Solution]]


:8.16. Let &lt;math&gt;G=(V,E)&lt;/math&gt; be an undirected weighted graph, and let &lt;math&gt;T&lt;/math&gt; be the shortest-path spanning tree rooted at a vertex &lt;math&gt;v&lt;/math&gt;. Suppose now that all the edge weights in &lt;math&gt;G&lt;/math&gt; are increased by a constant number &lt;math&gt;k&lt;/math&gt;. Is &lt;math&gt;T&lt;/math&gt; still the shortest-path spanning tree from &lt;math&gt;v&lt;/math&gt;?


:[[8.17]]. (a)Give an example of a weighted connected graph &lt;math&gt;G=(V,E)&lt;/math&gt; and a vertex &lt;math&gt;v&lt;/math&gt;, such that the minimum spanning tree of &lt;math&gt;G&lt;/math&gt; is the same as the shortest-path spanning tree rooted at &lt;math&gt;v&lt;/math&gt;.
:(b)Give an example of a weighted connected directed graph &lt;math&gt;G=(V,E)&lt;/math&gt; and a vertex &lt;math&gt;v&lt;/math&gt;, such that the minimum-cost spanning tree of &lt;math&gt;G&lt;/math&gt; is very different from the shortest-path spanning tree rooted at &lt;math&gt;v&lt;/math&gt;.
:(c)Can the two trees be completely disjointed?
[[8.17|Solution]]


:8.18. Either prove the following or give a counterexample:
:(a)Is the path between a pair of vertices in a minimum spanning tree of an undirected graph necessarily the shortest (minimum weight) path?
:(b)Suppose that the minimum spanning tree of the graph is unique. Is the path between a pair of vertices in a minimum spanning tree of an undirected graph necessarily the shortest (minimum weight) path?


:[[8.19]]. Give an efficient algorithm to find the shortest path from &lt;math&gt;x&lt;/math&gt; to &lt;math&gt;y&lt;/math&gt; in an undirected weighted graph &lt;math&gt;G = (V, E)&lt;/math&gt; with positive edge weights, subject to the constraint that this path must pass through a particular vertex &lt;math&gt;z&lt;/math&gt;.


:8.20. In certain graph problems, vertices have can have weights instead of or in addition to the weights of edges. Let &lt;math&gt;C_v&lt;/math&gt; be the cost of vertex &lt;math&gt;v&lt;/math&gt;, and &lt;math&gt;C_{(x,y)}&lt;/math&gt; the cost of the edge &lt;math&gt;(x,y)&lt;/math&gt;. This problem is concerned with finding the cheapest path between vertices &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; in a graph &lt;math&gt;G&lt;/math&gt;. The cost of a path is the sum of the costs of the edges and vertices encountered on the path.
:(a)Suppose that each edge in the graph has a weight of zero (while non-edges have a cost of &lt;math&gt;\infty&lt;/math&gt;). Assume that &lt;math&gt;C_v = 1&lt;/math&gt; for all vertices &lt;math&gt;1 \leq v \leq n&lt;/math&gt; (i.e., all vertices have the same cost). Give an ''efficient'' algorithm to find the cheapest path from &lt;math&gt;a&lt;/math&gt; to &lt;math&gt;b&lt;/math&gt; and its time complexity.
:(b)Now suppose that the vertex costs are not constant (but are all positive) and the edge costs remain as above. Give an ''efficient'' algorithm to find the cheapest path from &lt;math&gt;a&lt;/math&gt; to &lt;math&gt;b&lt;/math&gt; and its time complexity.
:(c)Now suppose that both the edge and vertex costs are not constant (but are all positive). Give an ''efficient'' algorithm to find the cheapest path from &lt;math&gt;a&lt;/math&gt; to &lt;math&gt;b&lt;/math&gt; and its time complexity.


:[[8.21]]. Give an &lt;math&gt;O(n^3)&lt;/math&gt; algorithm that takes an &lt;math&gt;n&lt;/math&gt;-vertex directed graph &lt;math&gt;G&lt;/math&gt; with positive edge lengths, and returns the length of the shortest cycle in the graph. This length is &lt;math&gt;\infty&lt;/math&gt; in the case of an acyclic graph.
[[8.21|Solution]]


:8.22. A highway network is represented by a weighted graph &lt;math&gt;G&lt;/math&gt;, with edges corresponding to roads and vertices corresponding to road intersections. Each road is labeled with the maximum possible height of vehicles that can pass through the road. Give an efficient algorithm to compute the maximum possible height of vehicles that can successfully travel from &lt;math&gt;s&lt;/math&gt; to &lt;math&gt;t&lt;/math&gt;. What is the runtime of your algorithm?


:[[8.23]]. You are given a directed graph &lt;math&gt;G&lt;/math&gt; with possibly negative weighted edges, in which the shortest path between any two vertices is guaranteed to have at most &lt;math&gt;k&lt;/math&gt; edges. Give an algorithm that finds the shortest path between two vertices &lt;math&gt;u&lt;/math&gt; and &lt;math&gt;v&lt;/math&gt; in &lt;math&gt;O(k * (n + m))&lt;/math&gt; time.
[[8.23|Solution]]


:8.24. Can we solve the single-source ''longest''-path problem by changing ''minimum'' to ''maximum'' in Dijkstra’s algorithm? If so, then prove your algorithm correct. If not, then provide a counterexample.


:[[8.25]]. Let &lt;math&gt;G = (V, E)&lt;/math&gt; be a weighted acyclic directed graph with possibly negative edge weights. Design a linear-time algorithm to solve the single-source shortest-path problem from a given source &lt;math&gt;v&lt;/math&gt;.
[[8.25|Solution]]


:8.26. Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a directed weighted graph such that all the weights are positive. Let &lt;math&gt;v&lt;/math&gt; and &lt;math&gt;w&lt;/math&gt; be two vertices in &lt;math&gt;G&lt;/math&gt; and &lt;math&gt;k \leq |V|&lt;/math&gt; be an integer. Design an algorithm to find the shortest path from &lt;math&gt;v&lt;/math&gt; to &lt;math&gt;w&lt;/math&gt; that contains exactly &lt;math&gt;k&lt;/math&gt; edges. Note that the path need not be simple.


:[[8.27]].''Arbitrage'' is the use of discrepancies in currency-exchange rates to make a profit. For example, there may be a small window of time during which 1 U.S. dollar buys 0.75 British pounds, 1 British pound buys 2 Australian dollars, and 1 Australian dollar buys 0.70 U.S. dollars. At such a time, a smart trader can trade one U.S. dollar and end up with &lt;math&gt;0.75 \times 2 \times 0.7 = 1.05&lt;/math&gt; U.S. dollars---a profit of 5%. Suppose that there are &lt;math&gt;n&lt;/math&gt; currencies &lt;math&gt;c_1,...,c_n&lt;/math&gt; and an &lt;math&gt;n \times n&lt;/math&gt; table &lt;math&gt;R&lt;/math&gt; of exchange rates, such that one unit of currency &lt;math&gt;c_i&lt;/math&gt; buys &lt;math&gt;R[i,j]&lt;/math&gt; units of currency &lt;math&gt;c_j&lt;/math&gt;. Devise and analyze an algorithm to determine the maximum value of &lt;math&gt; R[c_1,c_{i1}] \cdot R[c_{i1},c_{i2}] \cdots R[c_{i{k-1}},c_{ik}] \cdot R[c_{ik},c_1] &lt;/math&gt; Hint: think all-pairs shortest path.
[[8.27|Solution]]

===Network Flow and Matching===

:8.28. A matching in a graph is a set of disjoint edges—that is, edges that do not have common vertices. Give a linear-time algorithm to find a maximum matching in a tree.


:[[8.29]]. An edge cover of an undirected graph &lt;math&gt;G = (V, E)&lt;/math&gt; is a set of edges such that each vertex in the graph is incident to at least one edge from the set. Give an efficient algorithm, based on matching, to find the minimum-size edge cover for &lt;math&gt;G&lt;/math&gt;.
[[8.29|Solution]]


Back to [[Chapter List]]</text>
      <sha1>jmyjgwvqvslcf3cpyoa7gjv9811micv</sha1>
    </revision>
    <revision>
      <id>423</id>
      <parentid>238</parentid>
      <timestamp>2020-09-21T14:08:42Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Shortest Paths */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="11969">=Weighted Graph Algorithms=

===Simulating Graph Algorithms===

:[[8.1]]. For the graphs in Problem 7-1:
:(a) Draw the spanning forest after every iteration of the main loop in Kruskal’s algorithm.
:(b) Draw the spanning forest after every iteration of the main loop in Prim’s algorithm.
:(c) Find the shortest-path spanning tree rooted in &lt;math&gt;A&lt;/math&gt;.
:(d) Compute the maximum flow from &lt;math&gt;A&lt;/math&gt; to &lt;math&gt;H&lt;/math&gt;.
[[8.1|Solution]]

===Minimum Spanning Tree===

:8.2. Is the path between two vertices in a minimum spanning tree necessarily a shortest path between the two vertices in the full graph? Give a proof or a counterexample.


:[[8.3]]. Assume that all edges in the graph have distinct edge weights (i.e., no pair of edges have the same weight). Is the path between a pair of vertices in a minimum spanning tree necessarily a shortest path between the two vertices in the full graph? Give a proof or a counterexample.
[[8.3|Solution]]


:8.4. Can Prim’s and Kruskal’s algorithms yield different minimum spanning trees? Explain why or why not.


:[[8.5]]. Does either Prim’s or Kruskal’s algorithm work if there are negative edge weights? Explain why or why not.
[[8.5|Solution]]


:8.6. (a) Assume that all edges in the graph have distinct edge weights (i.e., no pair of edges have the same weight). Is the ''minimum spanning tree'' of this graph unique? Give a proof or a counterexample.
:(b) Again, assume that all edges in the graph have distinct edge weights (i.e. no pair of edges have the same weight). Is the ''shortest-path spanning tree'' of this graph unique? Give a proof or a counterexample.


:[[8.7]]. Suppose we are given the minimum spanning tree &lt;math&gt;T&lt;/math&gt; of a given graph &lt;math&gt;G&lt;/math&gt; (with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges) and a new edge &lt;math&gt;e = (u, v)&lt;/math&gt; of weight &lt;math&gt;w&lt;/math&gt; that we will add to &lt;math&gt;G&lt;/math&gt;. Give an efficient algorithm to find the minimum spanning tree of the graph &lt;math&gt;G + e&lt;/math&gt;. Your algorithm should run in &lt;math&gt;O(n)&lt;/math&gt; time to receive full credit.
[[8.7|Solution]]


:8.8. (a) Let &lt;math&gt;T&lt;/math&gt; be a minimum spanning tree of a weighted graph &lt;math&gt;G&lt;/math&gt;. Construct a new graph &lt;math&gt;G'&lt;/math&gt; by adding a weight of &lt;math&gt;k&lt;/math&gt; to every edge of &lt;math&gt;G&lt;/math&gt;. Do the edges of &lt;math&gt;T&lt;/math&gt; form a minimum spanning tree of &lt;math&gt;G'&lt;/math&gt;? Prove the statement or give a counterexample.
:(b) Let &lt;math&gt;P = {s, . . . , t}&lt;/math&gt; describe a shortest path between vertices &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt; of a weighted graph &lt;math&gt;G&lt;/math&gt;. Construct a new graph &lt;math&gt;G'&lt;/math&gt; by adding a weight of &lt;math&gt;k&lt;/math&gt; to every edge of &lt;math&gt;G&lt;/math&gt;. Does &lt;math&gt;P&lt;/math&gt; describe a shortest path from &lt;math&gt;s&lt;/math&gt; to &lt;math&gt;t&lt;/math&gt; in &lt;math&gt;G'&lt;/math&gt;? Prove the statement or give a counterexample.


:[[8.9]]. Devise and analyze an algorithm that takes a weighted graph &lt;math&gt;G&lt;/math&gt; and finds the smallest change in the cost to a non-minimum spanning tree edge that would cause a change in the minimum spanning tree of &lt;math&gt;G&lt;/math&gt;. Your algorithm must be correct and run in polynomial time.
[[8.9|Solution]]


:8.10. Consider the problem of finding a minimum-weight connected subset &lt;math&gt;T&lt;/math&gt; of edges from a weighted connected graph &lt;math&gt;G&lt;/math&gt;. The weight of &lt;math&gt;T&lt;/math&gt; is the sum of all the edge weights in &lt;math&gt;T&lt;/math&gt;.
:(a) Why is this problem not just the minimum spanning tree problem? (Hint: think negative weight edges.)
:(b) Give an efficient algorithm to compute the minimum-weight connected subset &lt;math&gt;T&lt;/math&gt;.


:[[8.11]]. Let &lt;math&gt;T = (V, E')&lt;/math&gt; be a minimum spanning tree of a given graph &lt;math&gt;G = (V, E)&lt;/math&gt; with positive edge weights. Now suppose the weight of a particular edge &lt;math&gt;e \in E&lt;/math&gt; is modified from &lt;math&gt;w(e)&lt;/math&gt; to a new value &lt;math&gt;\hat{w}(e)&lt;/math&gt;. We seek to update the minimum spanning tree &lt;math&gt;T&lt;/math&gt; to reflect this change without recomputing the entire tree from scratch. For each of the following four cases, give a linear-time algorithm to update the tree:
:(a)&lt;math&gt;e \notin E'&lt;/math&gt; and &lt;math&gt; \hat{w}(e) &gt; w(e)&lt;/math&gt;
:(b) &lt;math&gt;e \notin E'&lt;/math&gt; and &lt;math&gt;\hat{w}(e) &lt; w(e)&lt;/math&gt;
:(c) &lt;math&gt;e \in E'&lt;/math&gt; and &lt;math&gt;\hat{w}(e) &lt; w(e)&lt;/math&gt;
:(d) &lt;math&gt;e \in E' &lt;/math&gt; and &lt;math&gt;\hat{w}(e) &gt; w(e)&lt;/math&gt;
[[8.11|Solution]]


:8.12. Let &lt;math&gt;G=(V,E)&lt;/math&gt; be an undirected graph. A set &lt;math&gt;F \subseteq E&lt;/math&gt; of edges is called a ''feedback-edge set'' if every cycle of &lt;math&gt;G&lt;/math&gt; has at least one edge in &lt;math&gt;F&lt;/math&gt;.
:(a)Suppose that &lt;math&gt;G&lt;/math&gt; is unweighted. Design an efficient algorithm to find a minimum-size feedback-edge set.
:(b)Suppose that &lt;math&gt;G&lt;/math&gt; is a weighted undirected graph with positive edge weights. Design an efficient algorithm to find a minimum-weight feedback-edge set.

===Union Find===

:[[8.13]]. Devise an efficient data structure to handle the following operations on a weighted directed graph:
:(a)Merge two given components.
:(b)Locate which component contains a given vertex &lt;math&gt;v&lt;/math&gt;.
:(c)Retrieve a minimum edge from a given component.
[[8.13|Solution]]


:8.14. Design a data structure that can perform a sequence of, &lt;math&gt;m&lt;/math&gt; ''union'' and  ''find'' operations on a universal set of &lt;math&gt;n&lt;/math&gt; elements, consisting of a sequence of all ''unions'' followed by a sequence of all ''finds'', in time &lt;math&gt;O(m+n)&lt;/math&gt;.

===Shortest Paths===

:[[8:15]]. The ''single-destination shortest path'' problem for a directed graph seeks the shortest path ''from'' every vertex to a specified vertex &lt;math&gt;v&lt;/math&gt;. Give an efficient algorithm to solve the single-destination shortest paths problem.
[[8.15|Solution]]


:8.16. Let &lt;math&gt;G=(V,E)&lt;/math&gt; be an undirected weighted graph, and let &lt;math&gt;T&lt;/math&gt; be the shortest-path spanning tree rooted at a vertex &lt;math&gt;v&lt;/math&gt;. Suppose now that all the edge weights in &lt;math&gt;G&lt;/math&gt; are increased by a constant number &lt;math&gt;k&lt;/math&gt;. Is &lt;math&gt;T&lt;/math&gt; still the shortest-path spanning tree from &lt;math&gt;v&lt;/math&gt;?


:[[8.17]]. (a)Give an example of a weighted connected graph &lt;math&gt;G=(V,E)&lt;/math&gt; and a vertex &lt;math&gt;v&lt;/math&gt;, such that the minimum spanning tree of &lt;math&gt;G&lt;/math&gt; is the same as the shortest-path spanning tree rooted at &lt;math&gt;v&lt;/math&gt;.
:(b)Give an example of a weighted connected directed graph &lt;math&gt;G=(V,E)&lt;/math&gt; and a vertex &lt;math&gt;v&lt;/math&gt;, such that the minimum-cost spanning tree of &lt;math&gt;G&lt;/math&gt; is very different from the shortest-path spanning tree rooted at &lt;math&gt;v&lt;/math&gt;.
:(c)Can the two trees be completely disjointed?
[[8.17|Solution]]


:8.18. Either prove the following or give a counterexample:
:(a)Is the path between a pair of vertices in a minimum spanning tree of an undirected graph necessarily the shortest (minimum weight) path?
:(b)Suppose that the minimum spanning tree of the graph is unique. Is the path between a pair of vertices in a minimum spanning tree of an undirected graph necessarily the shortest (minimum weight) path?


:[[8.19]]. Give an efficient algorithm to find the shortest path from &lt;math&gt;x&lt;/math&gt; to &lt;math&gt;y&lt;/math&gt; in an undirected weighted graph &lt;math&gt;G = (V, E)&lt;/math&gt; with positive edge weights, subject to the constraint that this path must pass through a particular vertex &lt;math&gt;z&lt;/math&gt;.
[[8.19|Solution]]


:8.20. In certain graph problems, vertices have can have weights instead of or in addition to the weights of edges. Let &lt;math&gt;C_v&lt;/math&gt; be the cost of vertex &lt;math&gt;v&lt;/math&gt;, and &lt;math&gt;C_{(x,y)}&lt;/math&gt; the cost of the edge &lt;math&gt;(x,y)&lt;/math&gt;. This problem is concerned with finding the cheapest path between vertices &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; in a graph &lt;math&gt;G&lt;/math&gt;. The cost of a path is the sum of the costs of the edges and vertices encountered on the path.
:(a)Suppose that each edge in the graph has a weight of zero (while non-edges have a cost of &lt;math&gt;\infty&lt;/math&gt;). Assume that &lt;math&gt;C_v = 1&lt;/math&gt; for all vertices &lt;math&gt;1 \leq v \leq n&lt;/math&gt; (i.e., all vertices have the same cost). Give an ''efficient'' algorithm to find the cheapest path from &lt;math&gt;a&lt;/math&gt; to &lt;math&gt;b&lt;/math&gt; and its time complexity.
:(b)Now suppose that the vertex costs are not constant (but are all positive) and the edge costs remain as above. Give an ''efficient'' algorithm to find the cheapest path from &lt;math&gt;a&lt;/math&gt; to &lt;math&gt;b&lt;/math&gt; and its time complexity.
:(c)Now suppose that both the edge and vertex costs are not constant (but are all positive). Give an ''efficient'' algorithm to find the cheapest path from &lt;math&gt;a&lt;/math&gt; to &lt;math&gt;b&lt;/math&gt; and its time complexity.


:[[8.21]]. Give an &lt;math&gt;O(n^3)&lt;/math&gt; algorithm that takes an &lt;math&gt;n&lt;/math&gt;-vertex directed graph &lt;math&gt;G&lt;/math&gt; with positive edge lengths, and returns the length of the shortest cycle in the graph. This length is &lt;math&gt;\infty&lt;/math&gt; in the case of an acyclic graph.
[[8.21|Solution]]


:8.22. A highway network is represented by a weighted graph &lt;math&gt;G&lt;/math&gt;, with edges corresponding to roads and vertices corresponding to road intersections. Each road is labeled with the maximum possible height of vehicles that can pass through the road. Give an efficient algorithm to compute the maximum possible height of vehicles that can successfully travel from &lt;math&gt;s&lt;/math&gt; to &lt;math&gt;t&lt;/math&gt;. What is the runtime of your algorithm?


:[[8.23]]. You are given a directed graph &lt;math&gt;G&lt;/math&gt; with possibly negative weighted edges, in which the shortest path between any two vertices is guaranteed to have at most &lt;math&gt;k&lt;/math&gt; edges. Give an algorithm that finds the shortest path between two vertices &lt;math&gt;u&lt;/math&gt; and &lt;math&gt;v&lt;/math&gt; in &lt;math&gt;O(k * (n + m))&lt;/math&gt; time.
[[8.23|Solution]]


:8.24. Can we solve the single-source ''longest''-path problem by changing ''minimum'' to ''maximum'' in Dijkstra’s algorithm? If so, then prove your algorithm correct. If not, then provide a counterexample.


:[[8.25]]. Let &lt;math&gt;G = (V, E)&lt;/math&gt; be a weighted acyclic directed graph with possibly negative edge weights. Design a linear-time algorithm to solve the single-source shortest-path problem from a given source &lt;math&gt;v&lt;/math&gt;.
[[8.25|Solution]]


:8.26. Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a directed weighted graph such that all the weights are positive. Let &lt;math&gt;v&lt;/math&gt; and &lt;math&gt;w&lt;/math&gt; be two vertices in &lt;math&gt;G&lt;/math&gt; and &lt;math&gt;k \leq |V|&lt;/math&gt; be an integer. Design an algorithm to find the shortest path from &lt;math&gt;v&lt;/math&gt; to &lt;math&gt;w&lt;/math&gt; that contains exactly &lt;math&gt;k&lt;/math&gt; edges. Note that the path need not be simple.


:[[8.27]].''Arbitrage'' is the use of discrepancies in currency-exchange rates to make a profit. For example, there may be a small window of time during which 1 U.S. dollar buys 0.75 British pounds, 1 British pound buys 2 Australian dollars, and 1 Australian dollar buys 0.70 U.S. dollars. At such a time, a smart trader can trade one U.S. dollar and end up with &lt;math&gt;0.75 \times 2 \times 0.7 = 1.05&lt;/math&gt; U.S. dollars---a profit of 5%. Suppose that there are &lt;math&gt;n&lt;/math&gt; currencies &lt;math&gt;c_1,...,c_n&lt;/math&gt; and an &lt;math&gt;n \times n&lt;/math&gt; table &lt;math&gt;R&lt;/math&gt; of exchange rates, such that one unit of currency &lt;math&gt;c_i&lt;/math&gt; buys &lt;math&gt;R[i,j]&lt;/math&gt; units of currency &lt;math&gt;c_j&lt;/math&gt;. Devise and analyze an algorithm to determine the maximum value of &lt;math&gt; R[c_1,c_{i1}] \cdot R[c_{i1},c_{i2}] \cdots R[c_{i{k-1}},c_{ik}] \cdot R[c_{ik},c_1] &lt;/math&gt; Hint: think all-pairs shortest path.
[[8.27|Solution]]

===Network Flow and Matching===

:8.28. A matching in a graph is a set of disjoint edges—that is, edges that do not have common vertices. Give a linear-time algorithm to find a maximum matching in a tree.


:[[8.29]]. An edge cover of an undirected graph &lt;math&gt;G = (V, E)&lt;/math&gt; is a set of edges such that each vertex in the graph is incident to at least one edge from the set. Give an efficient algorithm, based on matching, to find the minimum-size edge cover for &lt;math&gt;G&lt;/math&gt;.
[[8.29|Solution]]


Back to [[Chapter List]]</text>
      <sha1>n7qmsugtv9lnrb3aszj1xr61l72q434</sha1>
    </revision>
    <revision>
      <id>428</id>
      <parentid>423</parentid>
      <timestamp>2020-09-21T14:10:28Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Shortest Paths */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="11970">=Weighted Graph Algorithms=

===Simulating Graph Algorithms===

:[[8.1]]. For the graphs in Problem 7-1:
:(a) Draw the spanning forest after every iteration of the main loop in Kruskal’s algorithm.
:(b) Draw the spanning forest after every iteration of the main loop in Prim’s algorithm.
:(c) Find the shortest-path spanning tree rooted in &lt;math&gt;A&lt;/math&gt;.
:(d) Compute the maximum flow from &lt;math&gt;A&lt;/math&gt; to &lt;math&gt;H&lt;/math&gt;.
[[8.1|Solution]]

===Minimum Spanning Tree===

:8.2. Is the path between two vertices in a minimum spanning tree necessarily a shortest path between the two vertices in the full graph? Give a proof or a counterexample.


:[[8.3]]. Assume that all edges in the graph have distinct edge weights (i.e., no pair of edges have the same weight). Is the path between a pair of vertices in a minimum spanning tree necessarily a shortest path between the two vertices in the full graph? Give a proof or a counterexample.
[[8.3|Solution]]


:8.4. Can Prim’s and Kruskal’s algorithms yield different minimum spanning trees? Explain why or why not.


:[[8.5]]. Does either Prim’s or Kruskal’s algorithm work if there are negative edge weights? Explain why or why not.
[[8.5|Solution]]


:8.6. (a) Assume that all edges in the graph have distinct edge weights (i.e., no pair of edges have the same weight). Is the ''minimum spanning tree'' of this graph unique? Give a proof or a counterexample.
:(b) Again, assume that all edges in the graph have distinct edge weights (i.e. no pair of edges have the same weight). Is the ''shortest-path spanning tree'' of this graph unique? Give a proof or a counterexample.


:[[8.7]]. Suppose we are given the minimum spanning tree &lt;math&gt;T&lt;/math&gt; of a given graph &lt;math&gt;G&lt;/math&gt; (with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges) and a new edge &lt;math&gt;e = (u, v)&lt;/math&gt; of weight &lt;math&gt;w&lt;/math&gt; that we will add to &lt;math&gt;G&lt;/math&gt;. Give an efficient algorithm to find the minimum spanning tree of the graph &lt;math&gt;G + e&lt;/math&gt;. Your algorithm should run in &lt;math&gt;O(n)&lt;/math&gt; time to receive full credit.
[[8.7|Solution]]


:8.8. (a) Let &lt;math&gt;T&lt;/math&gt; be a minimum spanning tree of a weighted graph &lt;math&gt;G&lt;/math&gt;. Construct a new graph &lt;math&gt;G'&lt;/math&gt; by adding a weight of &lt;math&gt;k&lt;/math&gt; to every edge of &lt;math&gt;G&lt;/math&gt;. Do the edges of &lt;math&gt;T&lt;/math&gt; form a minimum spanning tree of &lt;math&gt;G'&lt;/math&gt;? Prove the statement or give a counterexample.
:(b) Let &lt;math&gt;P = {s, . . . , t}&lt;/math&gt; describe a shortest path between vertices &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt; of a weighted graph &lt;math&gt;G&lt;/math&gt;. Construct a new graph &lt;math&gt;G'&lt;/math&gt; by adding a weight of &lt;math&gt;k&lt;/math&gt; to every edge of &lt;math&gt;G&lt;/math&gt;. Does &lt;math&gt;P&lt;/math&gt; describe a shortest path from &lt;math&gt;s&lt;/math&gt; to &lt;math&gt;t&lt;/math&gt; in &lt;math&gt;G'&lt;/math&gt;? Prove the statement or give a counterexample.


:[[8.9]]. Devise and analyze an algorithm that takes a weighted graph &lt;math&gt;G&lt;/math&gt; and finds the smallest change in the cost to a non-minimum spanning tree edge that would cause a change in the minimum spanning tree of &lt;math&gt;G&lt;/math&gt;. Your algorithm must be correct and run in polynomial time.
[[8.9|Solution]]


:8.10. Consider the problem of finding a minimum-weight connected subset &lt;math&gt;T&lt;/math&gt; of edges from a weighted connected graph &lt;math&gt;G&lt;/math&gt;. The weight of &lt;math&gt;T&lt;/math&gt; is the sum of all the edge weights in &lt;math&gt;T&lt;/math&gt;.
:(a) Why is this problem not just the minimum spanning tree problem? (Hint: think negative weight edges.)
:(b) Give an efficient algorithm to compute the minimum-weight connected subset &lt;math&gt;T&lt;/math&gt;.


:[[8.11]]. Let &lt;math&gt;T = (V, E')&lt;/math&gt; be a minimum spanning tree of a given graph &lt;math&gt;G = (V, E)&lt;/math&gt; with positive edge weights. Now suppose the weight of a particular edge &lt;math&gt;e \in E&lt;/math&gt; is modified from &lt;math&gt;w(e)&lt;/math&gt; to a new value &lt;math&gt;\hat{w}(e)&lt;/math&gt;. We seek to update the minimum spanning tree &lt;math&gt;T&lt;/math&gt; to reflect this change without recomputing the entire tree from scratch. For each of the following four cases, give a linear-time algorithm to update the tree:
:(a)&lt;math&gt;e \notin E'&lt;/math&gt; and &lt;math&gt; \hat{w}(e) &gt; w(e)&lt;/math&gt;
:(b) &lt;math&gt;e \notin E'&lt;/math&gt; and &lt;math&gt;\hat{w}(e) &lt; w(e)&lt;/math&gt;
:(c) &lt;math&gt;e \in E'&lt;/math&gt; and &lt;math&gt;\hat{w}(e) &lt; w(e)&lt;/math&gt;
:(d) &lt;math&gt;e \in E' &lt;/math&gt; and &lt;math&gt;\hat{w}(e) &gt; w(e)&lt;/math&gt;
[[8.11|Solution]]


:8.12. Let &lt;math&gt;G=(V,E)&lt;/math&gt; be an undirected graph. A set &lt;math&gt;F \subseteq E&lt;/math&gt; of edges is called a ''feedback-edge set'' if every cycle of &lt;math&gt;G&lt;/math&gt; has at least one edge in &lt;math&gt;F&lt;/math&gt;.
:(a)Suppose that &lt;math&gt;G&lt;/math&gt; is unweighted. Design an efficient algorithm to find a minimum-size feedback-edge set.
:(b)Suppose that &lt;math&gt;G&lt;/math&gt; is a weighted undirected graph with positive edge weights. Design an efficient algorithm to find a minimum-weight feedback-edge set.

===Union Find===

:[[8.13]]. Devise an efficient data structure to handle the following operations on a weighted directed graph:
:(a)Merge two given components.
:(b)Locate which component contains a given vertex &lt;math&gt;v&lt;/math&gt;.
:(c)Retrieve a minimum edge from a given component.
[[8.13|Solution]]


:8.14. Design a data structure that can perform a sequence of, &lt;math&gt;m&lt;/math&gt; ''union'' and  ''find'' operations on a universal set of &lt;math&gt;n&lt;/math&gt; elements, consisting of a sequence of all ''unions'' followed by a sequence of all ''finds'', in time &lt;math&gt;O(m+n)&lt;/math&gt;.

===Shortest Paths===

:[[8:15]]. The ''single-destination shortest path'' problem for a directed graph seeks the shortest path ''from'' every vertex to a specified vertex &lt;math&gt;v&lt;/math&gt;. Give an efficient algorithm to solve the single-destination shortest paths problem.
[[8.15|Solution]]


:8.16. Let &lt;math&gt;G=(V,E)&lt;/math&gt; be an undirected weighted graph, and let &lt;math&gt;T&lt;/math&gt; be the shortest-path spanning tree rooted at a vertex &lt;math&gt;v&lt;/math&gt;. Suppose now that all the edge weights in &lt;math&gt;G&lt;/math&gt; are increased by a constant number &lt;math&gt;k&lt;/math&gt;. Is &lt;math&gt;T&lt;/math&gt; still the shortest-path spanning tree from &lt;math&gt;v&lt;/math&gt;?


:[[8.17]]. (a)Give an example of a weighted connected graph &lt;math&gt;G=(V,E)&lt;/math&gt; and a vertex &lt;math&gt;v&lt;/math&gt;, such that the minimum spanning tree of &lt;math&gt;G&lt;/math&gt; is the same as the shortest-path spanning tree rooted at &lt;math&gt;v&lt;/math&gt;.
:(b)Give an example of a weighted connected directed graph &lt;math&gt;G=(V,E)&lt;/math&gt; and a vertex &lt;math&gt;v&lt;/math&gt;, such that the minimum-cost spanning tree of &lt;math&gt;G&lt;/math&gt; is very different from the shortest-path spanning tree rooted at &lt;math&gt;v&lt;/math&gt;.
:(c)Can the two trees be completely disjointed?
[[8.17|Solution]]


:8.18. Either prove the following or give a counterexample:
:(a)Is the path between a pair of vertices in a minimum spanning tree of an undirected graph necessarily the shortest (minimum weight) path?
:(b)Suppose that the minimum spanning tree of the graph is unique. Is the path between a pair of vertices in a minimum spanning tree of an undirected graph necessarily the shortest (minimum weight) path?


:[[8.19]]. Give an efficient algorithm to find the shortest path from &lt;math&gt;x&lt;/math&gt; to &lt;math&gt;y&lt;/math&gt; in an undirected weighted graph &lt;math&gt;G = (V, E)&lt;/math&gt; with positive edge weights, subject to the constraint that this path must pass through a particular vertex &lt;math&gt;z&lt;/math&gt;.
[[8.19|Solution]]


:8.20. In certain graph problems, vertices have can have weights instead of or in addition to the weights of edges. Let &lt;math&gt;C_v&lt;/math&gt; be the cost of vertex &lt;math&gt;v&lt;/math&gt;, and &lt;math&gt;C_{(x,y)}&lt;/math&gt; the cost of the edge &lt;math&gt;(x,y)&lt;/math&gt;. This problem is concerned with finding the cheapest path between vertices &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; in a graph &lt;math&gt;G&lt;/math&gt;. The cost of a path is the sum of the costs of the edges and vertices encountered on the path.
:(a)Suppose that each edge in the graph has a weight of zero (while non-edges have a cost of &lt;math&gt;\infty&lt;/math&gt;). Assume that &lt;math&gt;C_v = 1&lt;/math&gt; for all vertices &lt;math&gt;1 \leq v \leq n&lt;/math&gt; (i.e., all vertices have the same cost). Give an ''efficient'' algorithm to find the cheapest path from &lt;math&gt;a&lt;/math&gt; to &lt;math&gt;b&lt;/math&gt; and its time complexity.
:(b)Now suppose that the vertex costs are not constant (but are all positive) and the edge costs remain as above. Give an ''efficient'' algorithm to find the cheapest path from &lt;math&gt;a&lt;/math&gt; to &lt;math&gt;b&lt;/math&gt; and its time complexity.
:(c)Now suppose that both the edge and vertex costs are not constant (but are all positive). Give an ''efficient'' algorithm to find the cheapest path from &lt;math&gt;a&lt;/math&gt; to &lt;math&gt;b&lt;/math&gt; and its time complexity.


:[[8.21]]. Give an &lt;math&gt;O(n^3)&lt;/math&gt; algorithm that takes an &lt;math&gt;n&lt;/math&gt;-vertex directed graph &lt;math&gt;G&lt;/math&gt; with positive edge lengths, and returns the length of the shortest cycle in the graph. This length is &lt;math&gt;\infty&lt;/math&gt; in the case of an acyclic graph.
[[8.21|Solution]]


:8.22. A highway network is represented by a weighted graph &lt;math&gt;G&lt;/math&gt;, with edges corresponding to roads and vertices corresponding to road intersections. Each road is labeled with the maximum possible height of vehicles that can pass through the road. Give an efficient algorithm to compute the maximum possible height of vehicles that can successfully travel from &lt;math&gt;s&lt;/math&gt; to &lt;math&gt;t&lt;/math&gt;. What is the runtime of your algorithm?


:[[8.23]]. You are given a directed graph &lt;math&gt;G&lt;/math&gt; with possibly negative weighted edges, in which the shortest path between any two vertices is guaranteed to have at most &lt;math&gt;k&lt;/math&gt; edges. Give an algorithm that finds the shortest path between two vertices &lt;math&gt;u&lt;/math&gt; and &lt;math&gt;v&lt;/math&gt; in &lt;math&gt;O(k * (n + m))&lt;/math&gt; time.
[[8.23|Solution]]


:8.24. Can we solve the single-source ''longest''-path problem by changing ''minimum'' to ''maximum'' in Dijkstra’s algorithm? If so, then prove your algorithm correct. If not, then provide a counterexample.


:[[8.25]]. Let &lt;math&gt;G = (V, E)&lt;/math&gt; be a weighted acyclic directed graph with possibly negative edge weights. Design a linear-time algorithm to solve the single-source shortest-path problem from a given source &lt;math&gt;v&lt;/math&gt;.
[[8.25|Solution]]


:8.26. Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a directed weighted graph such that all the weights are positive. Let &lt;math&gt;v&lt;/math&gt; and &lt;math&gt;w&lt;/math&gt; be two vertices in &lt;math&gt;G&lt;/math&gt; and &lt;math&gt;k \leq |V|&lt;/math&gt; be an integer. Design an algorithm to find the shortest path from &lt;math&gt;v&lt;/math&gt; to &lt;math&gt;w&lt;/math&gt; that contains exactly &lt;math&gt;k&lt;/math&gt; edges. Note that the path need not be simple.


:[[8.27]]. ''Arbitrage'' is the use of discrepancies in currency-exchange rates to make a profit. For example, there may be a small window of time during which 1 U.S. dollar buys 0.75 British pounds, 1 British pound buys 2 Australian dollars, and 1 Australian dollar buys 0.70 U.S. dollars. At such a time, a smart trader can trade one U.S. dollar and end up with &lt;math&gt;0.75 \times 2 \times 0.7 = 1.05&lt;/math&gt; U.S. dollars---a profit of 5%. Suppose that there are &lt;math&gt;n&lt;/math&gt; currencies &lt;math&gt;c_1,...,c_n&lt;/math&gt; and an &lt;math&gt;n \times n&lt;/math&gt; table &lt;math&gt;R&lt;/math&gt; of exchange rates, such that one unit of currency &lt;math&gt;c_i&lt;/math&gt; buys &lt;math&gt;R[i,j]&lt;/math&gt; units of currency &lt;math&gt;c_j&lt;/math&gt;. Devise and analyze an algorithm to determine the maximum value of &lt;math&gt; R[c_1,c_{i1}] \cdot R[c_{i1},c_{i2}] \cdots R[c_{i{k-1}},c_{ik}] \cdot R[c_{ik},c_1] &lt;/math&gt; Hint: think all-pairs shortest path.
[[8.27|Solution]]

===Network Flow and Matching===

:8.28. A matching in a graph is a set of disjoint edges—that is, edges that do not have common vertices. Give a linear-time algorithm to find a maximum matching in a tree.


:[[8.29]]. An edge cover of an undirected graph &lt;math&gt;G = (V, E)&lt;/math&gt; is a set of edges such that each vertex in the graph is incident to at least one edge from the set. Give an efficient algorithm, based on matching, to find the minimum-size edge cover for &lt;math&gt;G&lt;/math&gt;.
[[8.29|Solution]]


Back to [[Chapter List]]</text>
      <sha1>1k4qndomw2aceadjuxnxlh9wxs58kfl</sha1>
    </revision>
    <revision>
      <id>433</id>
      <parentid>428</parentid>
      <timestamp>2020-09-21T14:13:01Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Shortest Paths */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="11970">=Weighted Graph Algorithms=

===Simulating Graph Algorithms===

:[[8.1]]. For the graphs in Problem 7-1:
:(a) Draw the spanning forest after every iteration of the main loop in Kruskal’s algorithm.
:(b) Draw the spanning forest after every iteration of the main loop in Prim’s algorithm.
:(c) Find the shortest-path spanning tree rooted in &lt;math&gt;A&lt;/math&gt;.
:(d) Compute the maximum flow from &lt;math&gt;A&lt;/math&gt; to &lt;math&gt;H&lt;/math&gt;.
[[8.1|Solution]]

===Minimum Spanning Tree===

:8.2. Is the path between two vertices in a minimum spanning tree necessarily a shortest path between the two vertices in the full graph? Give a proof or a counterexample.


:[[8.3]]. Assume that all edges in the graph have distinct edge weights (i.e., no pair of edges have the same weight). Is the path between a pair of vertices in a minimum spanning tree necessarily a shortest path between the two vertices in the full graph? Give a proof or a counterexample.
[[8.3|Solution]]


:8.4. Can Prim’s and Kruskal’s algorithms yield different minimum spanning trees? Explain why or why not.


:[[8.5]]. Does either Prim’s or Kruskal’s algorithm work if there are negative edge weights? Explain why or why not.
[[8.5|Solution]]


:8.6. (a) Assume that all edges in the graph have distinct edge weights (i.e., no pair of edges have the same weight). Is the ''minimum spanning tree'' of this graph unique? Give a proof or a counterexample.
:(b) Again, assume that all edges in the graph have distinct edge weights (i.e. no pair of edges have the same weight). Is the ''shortest-path spanning tree'' of this graph unique? Give a proof or a counterexample.


:[[8.7]]. Suppose we are given the minimum spanning tree &lt;math&gt;T&lt;/math&gt; of a given graph &lt;math&gt;G&lt;/math&gt; (with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges) and a new edge &lt;math&gt;e = (u, v)&lt;/math&gt; of weight &lt;math&gt;w&lt;/math&gt; that we will add to &lt;math&gt;G&lt;/math&gt;. Give an efficient algorithm to find the minimum spanning tree of the graph &lt;math&gt;G + e&lt;/math&gt;. Your algorithm should run in &lt;math&gt;O(n)&lt;/math&gt; time to receive full credit.
[[8.7|Solution]]


:8.8. (a) Let &lt;math&gt;T&lt;/math&gt; be a minimum spanning tree of a weighted graph &lt;math&gt;G&lt;/math&gt;. Construct a new graph &lt;math&gt;G'&lt;/math&gt; by adding a weight of &lt;math&gt;k&lt;/math&gt; to every edge of &lt;math&gt;G&lt;/math&gt;. Do the edges of &lt;math&gt;T&lt;/math&gt; form a minimum spanning tree of &lt;math&gt;G'&lt;/math&gt;? Prove the statement or give a counterexample.
:(b) Let &lt;math&gt;P = {s, . . . , t}&lt;/math&gt; describe a shortest path between vertices &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt; of a weighted graph &lt;math&gt;G&lt;/math&gt;. Construct a new graph &lt;math&gt;G'&lt;/math&gt; by adding a weight of &lt;math&gt;k&lt;/math&gt; to every edge of &lt;math&gt;G&lt;/math&gt;. Does &lt;math&gt;P&lt;/math&gt; describe a shortest path from &lt;math&gt;s&lt;/math&gt; to &lt;math&gt;t&lt;/math&gt; in &lt;math&gt;G'&lt;/math&gt;? Prove the statement or give a counterexample.


:[[8.9]]. Devise and analyze an algorithm that takes a weighted graph &lt;math&gt;G&lt;/math&gt; and finds the smallest change in the cost to a non-minimum spanning tree edge that would cause a change in the minimum spanning tree of &lt;math&gt;G&lt;/math&gt;. Your algorithm must be correct and run in polynomial time.
[[8.9|Solution]]


:8.10. Consider the problem of finding a minimum-weight connected subset &lt;math&gt;T&lt;/math&gt; of edges from a weighted connected graph &lt;math&gt;G&lt;/math&gt;. The weight of &lt;math&gt;T&lt;/math&gt; is the sum of all the edge weights in &lt;math&gt;T&lt;/math&gt;.
:(a) Why is this problem not just the minimum spanning tree problem? (Hint: think negative weight edges.)
:(b) Give an efficient algorithm to compute the minimum-weight connected subset &lt;math&gt;T&lt;/math&gt;.


:[[8.11]]. Let &lt;math&gt;T = (V, E')&lt;/math&gt; be a minimum spanning tree of a given graph &lt;math&gt;G = (V, E)&lt;/math&gt; with positive edge weights. Now suppose the weight of a particular edge &lt;math&gt;e \in E&lt;/math&gt; is modified from &lt;math&gt;w(e)&lt;/math&gt; to a new value &lt;math&gt;\hat{w}(e)&lt;/math&gt;. We seek to update the minimum spanning tree &lt;math&gt;T&lt;/math&gt; to reflect this change without recomputing the entire tree from scratch. For each of the following four cases, give a linear-time algorithm to update the tree:
:(a)&lt;math&gt;e \notin E'&lt;/math&gt; and &lt;math&gt; \hat{w}(e) &gt; w(e)&lt;/math&gt;
:(b) &lt;math&gt;e \notin E'&lt;/math&gt; and &lt;math&gt;\hat{w}(e) &lt; w(e)&lt;/math&gt;
:(c) &lt;math&gt;e \in E'&lt;/math&gt; and &lt;math&gt;\hat{w}(e) &lt; w(e)&lt;/math&gt;
:(d) &lt;math&gt;e \in E' &lt;/math&gt; and &lt;math&gt;\hat{w}(e) &gt; w(e)&lt;/math&gt;
[[8.11|Solution]]


:8.12. Let &lt;math&gt;G=(V,E)&lt;/math&gt; be an undirected graph. A set &lt;math&gt;F \subseteq E&lt;/math&gt; of edges is called a ''feedback-edge set'' if every cycle of &lt;math&gt;G&lt;/math&gt; has at least one edge in &lt;math&gt;F&lt;/math&gt;.
:(a)Suppose that &lt;math&gt;G&lt;/math&gt; is unweighted. Design an efficient algorithm to find a minimum-size feedback-edge set.
:(b)Suppose that &lt;math&gt;G&lt;/math&gt; is a weighted undirected graph with positive edge weights. Design an efficient algorithm to find a minimum-weight feedback-edge set.

===Union Find===

:[[8.13]]. Devise an efficient data structure to handle the following operations on a weighted directed graph:
:(a)Merge two given components.
:(b)Locate which component contains a given vertex &lt;math&gt;v&lt;/math&gt;.
:(c)Retrieve a minimum edge from a given component.
[[8.13|Solution]]


:8.14. Design a data structure that can perform a sequence of, &lt;math&gt;m&lt;/math&gt; ''union'' and  ''find'' operations on a universal set of &lt;math&gt;n&lt;/math&gt; elements, consisting of a sequence of all ''unions'' followed by a sequence of all ''finds'', in time &lt;math&gt;O(m+n)&lt;/math&gt;.

===Shortest Paths===

:[[8.15]]. The ''single-destination shortest path'' problem for a directed graph seeks the shortest path ''from'' every vertex to a specified vertex &lt;math&gt;v&lt;/math&gt;. Give an efficient algorithm to solve the single-destination shortest paths problem.
[[8.15|Solution]]


:8.16. Let &lt;math&gt;G=(V,E)&lt;/math&gt; be an undirected weighted graph, and let &lt;math&gt;T&lt;/math&gt; be the shortest-path spanning tree rooted at a vertex &lt;math&gt;v&lt;/math&gt;. Suppose now that all the edge weights in &lt;math&gt;G&lt;/math&gt; are increased by a constant number &lt;math&gt;k&lt;/math&gt;. Is &lt;math&gt;T&lt;/math&gt; still the shortest-path spanning tree from &lt;math&gt;v&lt;/math&gt;?


:[[8.17]]. (a)Give an example of a weighted connected graph &lt;math&gt;G=(V,E)&lt;/math&gt; and a vertex &lt;math&gt;v&lt;/math&gt;, such that the minimum spanning tree of &lt;math&gt;G&lt;/math&gt; is the same as the shortest-path spanning tree rooted at &lt;math&gt;v&lt;/math&gt;.
:(b)Give an example of a weighted connected directed graph &lt;math&gt;G=(V,E)&lt;/math&gt; and a vertex &lt;math&gt;v&lt;/math&gt;, such that the minimum-cost spanning tree of &lt;math&gt;G&lt;/math&gt; is very different from the shortest-path spanning tree rooted at &lt;math&gt;v&lt;/math&gt;.
:(c)Can the two trees be completely disjointed?
[[8.17|Solution]]


:8.18. Either prove the following or give a counterexample:
:(a)Is the path between a pair of vertices in a minimum spanning tree of an undirected graph necessarily the shortest (minimum weight) path?
:(b)Suppose that the minimum spanning tree of the graph is unique. Is the path between a pair of vertices in a minimum spanning tree of an undirected graph necessarily the shortest (minimum weight) path?


:[[8.19]]. Give an efficient algorithm to find the shortest path from &lt;math&gt;x&lt;/math&gt; to &lt;math&gt;y&lt;/math&gt; in an undirected weighted graph &lt;math&gt;G = (V, E)&lt;/math&gt; with positive edge weights, subject to the constraint that this path must pass through a particular vertex &lt;math&gt;z&lt;/math&gt;.
[[8.19|Solution]]


:8.20. In certain graph problems, vertices have can have weights instead of or in addition to the weights of edges. Let &lt;math&gt;C_v&lt;/math&gt; be the cost of vertex &lt;math&gt;v&lt;/math&gt;, and &lt;math&gt;C_{(x,y)}&lt;/math&gt; the cost of the edge &lt;math&gt;(x,y)&lt;/math&gt;. This problem is concerned with finding the cheapest path between vertices &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; in a graph &lt;math&gt;G&lt;/math&gt;. The cost of a path is the sum of the costs of the edges and vertices encountered on the path.
:(a)Suppose that each edge in the graph has a weight of zero (while non-edges have a cost of &lt;math&gt;\infty&lt;/math&gt;). Assume that &lt;math&gt;C_v = 1&lt;/math&gt; for all vertices &lt;math&gt;1 \leq v \leq n&lt;/math&gt; (i.e., all vertices have the same cost). Give an ''efficient'' algorithm to find the cheapest path from &lt;math&gt;a&lt;/math&gt; to &lt;math&gt;b&lt;/math&gt; and its time complexity.
:(b)Now suppose that the vertex costs are not constant (but are all positive) and the edge costs remain as above. Give an ''efficient'' algorithm to find the cheapest path from &lt;math&gt;a&lt;/math&gt; to &lt;math&gt;b&lt;/math&gt; and its time complexity.
:(c)Now suppose that both the edge and vertex costs are not constant (but are all positive). Give an ''efficient'' algorithm to find the cheapest path from &lt;math&gt;a&lt;/math&gt; to &lt;math&gt;b&lt;/math&gt; and its time complexity.


:[[8.21]]. Give an &lt;math&gt;O(n^3)&lt;/math&gt; algorithm that takes an &lt;math&gt;n&lt;/math&gt;-vertex directed graph &lt;math&gt;G&lt;/math&gt; with positive edge lengths, and returns the length of the shortest cycle in the graph. This length is &lt;math&gt;\infty&lt;/math&gt; in the case of an acyclic graph.
[[8.21|Solution]]


:8.22. A highway network is represented by a weighted graph &lt;math&gt;G&lt;/math&gt;, with edges corresponding to roads and vertices corresponding to road intersections. Each road is labeled with the maximum possible height of vehicles that can pass through the road. Give an efficient algorithm to compute the maximum possible height of vehicles that can successfully travel from &lt;math&gt;s&lt;/math&gt; to &lt;math&gt;t&lt;/math&gt;. What is the runtime of your algorithm?


:[[8.23]]. You are given a directed graph &lt;math&gt;G&lt;/math&gt; with possibly negative weighted edges, in which the shortest path between any two vertices is guaranteed to have at most &lt;math&gt;k&lt;/math&gt; edges. Give an algorithm that finds the shortest path between two vertices &lt;math&gt;u&lt;/math&gt; and &lt;math&gt;v&lt;/math&gt; in &lt;math&gt;O(k * (n + m))&lt;/math&gt; time.
[[8.23|Solution]]


:8.24. Can we solve the single-source ''longest''-path problem by changing ''minimum'' to ''maximum'' in Dijkstra’s algorithm? If so, then prove your algorithm correct. If not, then provide a counterexample.


:[[8.25]]. Let &lt;math&gt;G = (V, E)&lt;/math&gt; be a weighted acyclic directed graph with possibly negative edge weights. Design a linear-time algorithm to solve the single-source shortest-path problem from a given source &lt;math&gt;v&lt;/math&gt;.
[[8.25|Solution]]


:8.26. Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a directed weighted graph such that all the weights are positive. Let &lt;math&gt;v&lt;/math&gt; and &lt;math&gt;w&lt;/math&gt; be two vertices in &lt;math&gt;G&lt;/math&gt; and &lt;math&gt;k \leq |V|&lt;/math&gt; be an integer. Design an algorithm to find the shortest path from &lt;math&gt;v&lt;/math&gt; to &lt;math&gt;w&lt;/math&gt; that contains exactly &lt;math&gt;k&lt;/math&gt; edges. Note that the path need not be simple.


:[[8.27]]. ''Arbitrage'' is the use of discrepancies in currency-exchange rates to make a profit. For example, there may be a small window of time during which 1 U.S. dollar buys 0.75 British pounds, 1 British pound buys 2 Australian dollars, and 1 Australian dollar buys 0.70 U.S. dollars. At such a time, a smart trader can trade one U.S. dollar and end up with &lt;math&gt;0.75 \times 2 \times 0.7 = 1.05&lt;/math&gt; U.S. dollars---a profit of 5%. Suppose that there are &lt;math&gt;n&lt;/math&gt; currencies &lt;math&gt;c_1,...,c_n&lt;/math&gt; and an &lt;math&gt;n \times n&lt;/math&gt; table &lt;math&gt;R&lt;/math&gt; of exchange rates, such that one unit of currency &lt;math&gt;c_i&lt;/math&gt; buys &lt;math&gt;R[i,j]&lt;/math&gt; units of currency &lt;math&gt;c_j&lt;/math&gt;. Devise and analyze an algorithm to determine the maximum value of &lt;math&gt; R[c_1,c_{i1}] \cdot R[c_{i1},c_{i2}] \cdots R[c_{i{k-1}},c_{ik}] \cdot R[c_{ik},c_1] &lt;/math&gt; Hint: think all-pairs shortest path.
[[8.27|Solution]]

===Network Flow and Matching===

:8.28. A matching in a graph is a set of disjoint edges—that is, edges that do not have common vertices. Give a linear-time algorithm to find a maximum matching in a tree.


:[[8.29]]. An edge cover of an undirected graph &lt;math&gt;G = (V, E)&lt;/math&gt; is a set of edges such that each vertex in the graph is incident to at least one edge from the set. Give an efficient algorithm, based on matching, to find the minimum-size edge cover for &lt;math&gt;G&lt;/math&gt;.
[[8.29|Solution]]


Back to [[Chapter List]]</text>
      <sha1>e08daevzwdetohxzrcafshyoy2mdd3g</sha1>
    </revision>
    <revision>
      <id>454</id>
      <parentid>433</parentid>
      <timestamp>2020-10-01T18:09:48Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <minor/>
      <comment>Protected "[[Chapter 8]]" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="11970">=Weighted Graph Algorithms=

===Simulating Graph Algorithms===

:[[8.1]]. For the graphs in Problem 7-1:
:(a) Draw the spanning forest after every iteration of the main loop in Kruskal’s algorithm.
:(b) Draw the spanning forest after every iteration of the main loop in Prim’s algorithm.
:(c) Find the shortest-path spanning tree rooted in &lt;math&gt;A&lt;/math&gt;.
:(d) Compute the maximum flow from &lt;math&gt;A&lt;/math&gt; to &lt;math&gt;H&lt;/math&gt;.
[[8.1|Solution]]

===Minimum Spanning Tree===

:8.2. Is the path between two vertices in a minimum spanning tree necessarily a shortest path between the two vertices in the full graph? Give a proof or a counterexample.


:[[8.3]]. Assume that all edges in the graph have distinct edge weights (i.e., no pair of edges have the same weight). Is the path between a pair of vertices in a minimum spanning tree necessarily a shortest path between the two vertices in the full graph? Give a proof or a counterexample.
[[8.3|Solution]]


:8.4. Can Prim’s and Kruskal’s algorithms yield different minimum spanning trees? Explain why or why not.


:[[8.5]]. Does either Prim’s or Kruskal’s algorithm work if there are negative edge weights? Explain why or why not.
[[8.5|Solution]]


:8.6. (a) Assume that all edges in the graph have distinct edge weights (i.e., no pair of edges have the same weight). Is the ''minimum spanning tree'' of this graph unique? Give a proof or a counterexample.
:(b) Again, assume that all edges in the graph have distinct edge weights (i.e. no pair of edges have the same weight). Is the ''shortest-path spanning tree'' of this graph unique? Give a proof or a counterexample.


:[[8.7]]. Suppose we are given the minimum spanning tree &lt;math&gt;T&lt;/math&gt; of a given graph &lt;math&gt;G&lt;/math&gt; (with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges) and a new edge &lt;math&gt;e = (u, v)&lt;/math&gt; of weight &lt;math&gt;w&lt;/math&gt; that we will add to &lt;math&gt;G&lt;/math&gt;. Give an efficient algorithm to find the minimum spanning tree of the graph &lt;math&gt;G + e&lt;/math&gt;. Your algorithm should run in &lt;math&gt;O(n)&lt;/math&gt; time to receive full credit.
[[8.7|Solution]]


:8.8. (a) Let &lt;math&gt;T&lt;/math&gt; be a minimum spanning tree of a weighted graph &lt;math&gt;G&lt;/math&gt;. Construct a new graph &lt;math&gt;G'&lt;/math&gt; by adding a weight of &lt;math&gt;k&lt;/math&gt; to every edge of &lt;math&gt;G&lt;/math&gt;. Do the edges of &lt;math&gt;T&lt;/math&gt; form a minimum spanning tree of &lt;math&gt;G'&lt;/math&gt;? Prove the statement or give a counterexample.
:(b) Let &lt;math&gt;P = {s, . . . , t}&lt;/math&gt; describe a shortest path between vertices &lt;math&gt;s&lt;/math&gt; and &lt;math&gt;t&lt;/math&gt; of a weighted graph &lt;math&gt;G&lt;/math&gt;. Construct a new graph &lt;math&gt;G'&lt;/math&gt; by adding a weight of &lt;math&gt;k&lt;/math&gt; to every edge of &lt;math&gt;G&lt;/math&gt;. Does &lt;math&gt;P&lt;/math&gt; describe a shortest path from &lt;math&gt;s&lt;/math&gt; to &lt;math&gt;t&lt;/math&gt; in &lt;math&gt;G'&lt;/math&gt;? Prove the statement or give a counterexample.


:[[8.9]]. Devise and analyze an algorithm that takes a weighted graph &lt;math&gt;G&lt;/math&gt; and finds the smallest change in the cost to a non-minimum spanning tree edge that would cause a change in the minimum spanning tree of &lt;math&gt;G&lt;/math&gt;. Your algorithm must be correct and run in polynomial time.
[[8.9|Solution]]


:8.10. Consider the problem of finding a minimum-weight connected subset &lt;math&gt;T&lt;/math&gt; of edges from a weighted connected graph &lt;math&gt;G&lt;/math&gt;. The weight of &lt;math&gt;T&lt;/math&gt; is the sum of all the edge weights in &lt;math&gt;T&lt;/math&gt;.
:(a) Why is this problem not just the minimum spanning tree problem? (Hint: think negative weight edges.)
:(b) Give an efficient algorithm to compute the minimum-weight connected subset &lt;math&gt;T&lt;/math&gt;.


:[[8.11]]. Let &lt;math&gt;T = (V, E')&lt;/math&gt; be a minimum spanning tree of a given graph &lt;math&gt;G = (V, E)&lt;/math&gt; with positive edge weights. Now suppose the weight of a particular edge &lt;math&gt;e \in E&lt;/math&gt; is modified from &lt;math&gt;w(e)&lt;/math&gt; to a new value &lt;math&gt;\hat{w}(e)&lt;/math&gt;. We seek to update the minimum spanning tree &lt;math&gt;T&lt;/math&gt; to reflect this change without recomputing the entire tree from scratch. For each of the following four cases, give a linear-time algorithm to update the tree:
:(a)&lt;math&gt;e \notin E'&lt;/math&gt; and &lt;math&gt; \hat{w}(e) &gt; w(e)&lt;/math&gt;
:(b) &lt;math&gt;e \notin E'&lt;/math&gt; and &lt;math&gt;\hat{w}(e) &lt; w(e)&lt;/math&gt;
:(c) &lt;math&gt;e \in E'&lt;/math&gt; and &lt;math&gt;\hat{w}(e) &lt; w(e)&lt;/math&gt;
:(d) &lt;math&gt;e \in E' &lt;/math&gt; and &lt;math&gt;\hat{w}(e) &gt; w(e)&lt;/math&gt;
[[8.11|Solution]]


:8.12. Let &lt;math&gt;G=(V,E)&lt;/math&gt; be an undirected graph. A set &lt;math&gt;F \subseteq E&lt;/math&gt; of edges is called a ''feedback-edge set'' if every cycle of &lt;math&gt;G&lt;/math&gt; has at least one edge in &lt;math&gt;F&lt;/math&gt;.
:(a)Suppose that &lt;math&gt;G&lt;/math&gt; is unweighted. Design an efficient algorithm to find a minimum-size feedback-edge set.
:(b)Suppose that &lt;math&gt;G&lt;/math&gt; is a weighted undirected graph with positive edge weights. Design an efficient algorithm to find a minimum-weight feedback-edge set.

===Union Find===

:[[8.13]]. Devise an efficient data structure to handle the following operations on a weighted directed graph:
:(a)Merge two given components.
:(b)Locate which component contains a given vertex &lt;math&gt;v&lt;/math&gt;.
:(c)Retrieve a minimum edge from a given component.
[[8.13|Solution]]


:8.14. Design a data structure that can perform a sequence of, &lt;math&gt;m&lt;/math&gt; ''union'' and  ''find'' operations on a universal set of &lt;math&gt;n&lt;/math&gt; elements, consisting of a sequence of all ''unions'' followed by a sequence of all ''finds'', in time &lt;math&gt;O(m+n)&lt;/math&gt;.

===Shortest Paths===

:[[8.15]]. The ''single-destination shortest path'' problem for a directed graph seeks the shortest path ''from'' every vertex to a specified vertex &lt;math&gt;v&lt;/math&gt;. Give an efficient algorithm to solve the single-destination shortest paths problem.
[[8.15|Solution]]


:8.16. Let &lt;math&gt;G=(V,E)&lt;/math&gt; be an undirected weighted graph, and let &lt;math&gt;T&lt;/math&gt; be the shortest-path spanning tree rooted at a vertex &lt;math&gt;v&lt;/math&gt;. Suppose now that all the edge weights in &lt;math&gt;G&lt;/math&gt; are increased by a constant number &lt;math&gt;k&lt;/math&gt;. Is &lt;math&gt;T&lt;/math&gt; still the shortest-path spanning tree from &lt;math&gt;v&lt;/math&gt;?


:[[8.17]]. (a)Give an example of a weighted connected graph &lt;math&gt;G=(V,E)&lt;/math&gt; and a vertex &lt;math&gt;v&lt;/math&gt;, such that the minimum spanning tree of &lt;math&gt;G&lt;/math&gt; is the same as the shortest-path spanning tree rooted at &lt;math&gt;v&lt;/math&gt;.
:(b)Give an example of a weighted connected directed graph &lt;math&gt;G=(V,E)&lt;/math&gt; and a vertex &lt;math&gt;v&lt;/math&gt;, such that the minimum-cost spanning tree of &lt;math&gt;G&lt;/math&gt; is very different from the shortest-path spanning tree rooted at &lt;math&gt;v&lt;/math&gt;.
:(c)Can the two trees be completely disjointed?
[[8.17|Solution]]


:8.18. Either prove the following or give a counterexample:
:(a)Is the path between a pair of vertices in a minimum spanning tree of an undirected graph necessarily the shortest (minimum weight) path?
:(b)Suppose that the minimum spanning tree of the graph is unique. Is the path between a pair of vertices in a minimum spanning tree of an undirected graph necessarily the shortest (minimum weight) path?


:[[8.19]]. Give an efficient algorithm to find the shortest path from &lt;math&gt;x&lt;/math&gt; to &lt;math&gt;y&lt;/math&gt; in an undirected weighted graph &lt;math&gt;G = (V, E)&lt;/math&gt; with positive edge weights, subject to the constraint that this path must pass through a particular vertex &lt;math&gt;z&lt;/math&gt;.
[[8.19|Solution]]


:8.20. In certain graph problems, vertices have can have weights instead of or in addition to the weights of edges. Let &lt;math&gt;C_v&lt;/math&gt; be the cost of vertex &lt;math&gt;v&lt;/math&gt;, and &lt;math&gt;C_{(x,y)}&lt;/math&gt; the cost of the edge &lt;math&gt;(x,y)&lt;/math&gt;. This problem is concerned with finding the cheapest path between vertices &lt;math&gt;a&lt;/math&gt; and &lt;math&gt;b&lt;/math&gt; in a graph &lt;math&gt;G&lt;/math&gt;. The cost of a path is the sum of the costs of the edges and vertices encountered on the path.
:(a)Suppose that each edge in the graph has a weight of zero (while non-edges have a cost of &lt;math&gt;\infty&lt;/math&gt;). Assume that &lt;math&gt;C_v = 1&lt;/math&gt; for all vertices &lt;math&gt;1 \leq v \leq n&lt;/math&gt; (i.e., all vertices have the same cost). Give an ''efficient'' algorithm to find the cheapest path from &lt;math&gt;a&lt;/math&gt; to &lt;math&gt;b&lt;/math&gt; and its time complexity.
:(b)Now suppose that the vertex costs are not constant (but are all positive) and the edge costs remain as above. Give an ''efficient'' algorithm to find the cheapest path from &lt;math&gt;a&lt;/math&gt; to &lt;math&gt;b&lt;/math&gt; and its time complexity.
:(c)Now suppose that both the edge and vertex costs are not constant (but are all positive). Give an ''efficient'' algorithm to find the cheapest path from &lt;math&gt;a&lt;/math&gt; to &lt;math&gt;b&lt;/math&gt; and its time complexity.


:[[8.21]]. Give an &lt;math&gt;O(n^3)&lt;/math&gt; algorithm that takes an &lt;math&gt;n&lt;/math&gt;-vertex directed graph &lt;math&gt;G&lt;/math&gt; with positive edge lengths, and returns the length of the shortest cycle in the graph. This length is &lt;math&gt;\infty&lt;/math&gt; in the case of an acyclic graph.
[[8.21|Solution]]


:8.22. A highway network is represented by a weighted graph &lt;math&gt;G&lt;/math&gt;, with edges corresponding to roads and vertices corresponding to road intersections. Each road is labeled with the maximum possible height of vehicles that can pass through the road. Give an efficient algorithm to compute the maximum possible height of vehicles that can successfully travel from &lt;math&gt;s&lt;/math&gt; to &lt;math&gt;t&lt;/math&gt;. What is the runtime of your algorithm?


:[[8.23]]. You are given a directed graph &lt;math&gt;G&lt;/math&gt; with possibly negative weighted edges, in which the shortest path between any two vertices is guaranteed to have at most &lt;math&gt;k&lt;/math&gt; edges. Give an algorithm that finds the shortest path between two vertices &lt;math&gt;u&lt;/math&gt; and &lt;math&gt;v&lt;/math&gt; in &lt;math&gt;O(k * (n + m))&lt;/math&gt; time.
[[8.23|Solution]]


:8.24. Can we solve the single-source ''longest''-path problem by changing ''minimum'' to ''maximum'' in Dijkstra’s algorithm? If so, then prove your algorithm correct. If not, then provide a counterexample.


:[[8.25]]. Let &lt;math&gt;G = (V, E)&lt;/math&gt; be a weighted acyclic directed graph with possibly negative edge weights. Design a linear-time algorithm to solve the single-source shortest-path problem from a given source &lt;math&gt;v&lt;/math&gt;.
[[8.25|Solution]]


:8.26. Let &lt;math&gt;G=(V,E)&lt;/math&gt; be a directed weighted graph such that all the weights are positive. Let &lt;math&gt;v&lt;/math&gt; and &lt;math&gt;w&lt;/math&gt; be two vertices in &lt;math&gt;G&lt;/math&gt; and &lt;math&gt;k \leq |V|&lt;/math&gt; be an integer. Design an algorithm to find the shortest path from &lt;math&gt;v&lt;/math&gt; to &lt;math&gt;w&lt;/math&gt; that contains exactly &lt;math&gt;k&lt;/math&gt; edges. Note that the path need not be simple.


:[[8.27]]. ''Arbitrage'' is the use of discrepancies in currency-exchange rates to make a profit. For example, there may be a small window of time during which 1 U.S. dollar buys 0.75 British pounds, 1 British pound buys 2 Australian dollars, and 1 Australian dollar buys 0.70 U.S. dollars. At such a time, a smart trader can trade one U.S. dollar and end up with &lt;math&gt;0.75 \times 2 \times 0.7 = 1.05&lt;/math&gt; U.S. dollars---a profit of 5%. Suppose that there are &lt;math&gt;n&lt;/math&gt; currencies &lt;math&gt;c_1,...,c_n&lt;/math&gt; and an &lt;math&gt;n \times n&lt;/math&gt; table &lt;math&gt;R&lt;/math&gt; of exchange rates, such that one unit of currency &lt;math&gt;c_i&lt;/math&gt; buys &lt;math&gt;R[i,j]&lt;/math&gt; units of currency &lt;math&gt;c_j&lt;/math&gt;. Devise and analyze an algorithm to determine the maximum value of &lt;math&gt; R[c_1,c_{i1}] \cdot R[c_{i1},c_{i2}] \cdots R[c_{i{k-1}},c_{ik}] \cdot R[c_{ik},c_1] &lt;/math&gt; Hint: think all-pairs shortest path.
[[8.27|Solution]]

===Network Flow and Matching===

:8.28. A matching in a graph is a set of disjoint edges—that is, edges that do not have common vertices. Give a linear-time algorithm to find a maximum matching in a tree.


:[[8.29]]. An edge cover of an undirected graph &lt;math&gt;G = (V, E)&lt;/math&gt; is a set of edges such that each vertex in the graph is incident to at least one edge from the set. Give an efficient algorithm, based on matching, to find the minimum-size edge cover for &lt;math&gt;G&lt;/math&gt;.
[[8.29|Solution]]


Back to [[Chapter List]]</text>
      <sha1>e08daevzwdetohxzrcafshyoy2mdd3g</sha1>
    </revision>
  </page>
  <page>
    <title>Chapter 9</title>
    <ns>0</ns>
    <id>12</id>
    <revision>
      <id>21</id>
      <timestamp>2020-08-23T19:35:32Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Problems   Back to [[Chapter List]]"</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="35">Problems


Back to [[Chapter List]]</text>
      <sha1>95722ndl4ewzic1ak6z8g4auy0tqhc6</sha1>
    </revision>
    <revision>
      <id>119</id>
      <parentid>21</parentid>
      <timestamp>2020-09-07T19:18:55Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="517">=Combinatorial Search=

===Permutations===

:[[9.1]]


:9.2


:[[9.3]]


:9.4


:[[9.5]]


===Backtracking===

:9.6


:[[9.7]]


:9.8


:[[9.9]]


:9.10


:[[9.11]]


:9.12


:[[9.13]]


:9.14


:[[9.15]]


===Games and Puzzles===

:9.16


:[[9.17]]


:9.18


:[[9.19]]


:9.20


===Combinatorial Optimization=== 

:[[9.21]]


:9.22


:[[9.23]]


:9.24


:[[9.25]]


:9.26


:[[9.27]]


===Interview Problems===

:9.28


:[[9.27]]


:9.28


:[[9.29]]


:9.30


:[[9.31]]


:9.32


:[[9.33]]


Back to [[Chapter List]]</text>
      <sha1>jva4nzyg6jxoywa45w9hl62ftwn3mqa</sha1>
    </revision>
    <revision>
      <id>224</id>
      <parentid>119</parentid>
      <timestamp>2020-09-13T21:08:55Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Permutations */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="2484">=Combinatorial Search=

===Permutations===

:[[9.1]]. A ''derangement'' is a permutation &lt;math&gt;p&lt;/math&gt; of &lt;math&gt;{1, . . . , n}&lt;/math&gt; such that no item is in its proper position, that is, &lt;math&gt;p_i 6= i&lt;/math&gt; for all &lt;math&gt;1 \leq i \leq n&lt;/math&gt;. Write an efficient backtracking program with pruning that constructs all the derangements of &lt;math&gt;n&lt;/math&gt; items.
[[9.1|Soluiton]]


:9.2. ''Multisets'' are allowed to have repeated elements. A multiset of n items may thus have fewer than &lt;math&gt;n!&lt;/math&gt; distinct permutations. For example, {1, 1, 2, 2} has only six distinct permutations: [1, 1, 2, 2], [1, 2, 1, 2], [1, 2, 2, 1], [2, 1, 1, 2], [2, 1, 2, 1], and [2, 2, 1, 1]. Design and implement an efficient algorithm for constructing all permutations of a multiset.


:[[9.3]]. For a given a positive integer &lt;math&gt;n&lt;/math&gt;, find all permutations of the &lt;math&gt;2n&lt;/math&gt; elements of the multiset &lt;math&gt;S = {1, 1, 2, 2, 3, 3, . . . , n, n}&lt;/math&gt; such that for each integer from 1 to &lt;math&gt;n&lt;/math&gt; the number of intervening elements between its two appearances is equal to value of the element. For example, when &lt;math&gt;n = 3&lt;/math&gt; the two possible solutions are [3, 1, 2, 1, 3, 2] and [2, 3, 1, 2, 1, 3].
[[9.3|Solution]]


:9.4. Design and implement an algorithm for testing whether two graphs are isomorphic. The graph isomorphism problem is discussed in Section 19.9 (page 610). With proper pruning, graphs on hundreds of vertices can be tested in a reasonable time.


:[[9.5]]. The set &lt;math&gt;{1, 2, 3, ..., n}&lt;/math&gt; contains a total of &lt;math&gt;n!&lt;/math&gt; distinct permutations. By listing and labeling all of the permutations in ascending lexicographic order, we get the following sequence for &lt;math&gt;n = 3&lt;/math&gt;: 
&lt;center&gt;&lt;math&gt;[123, 132, 213, 231, 312, 321]&lt;/math&gt;&lt;/center&gt;
:Give an efficient algorithm that returns the &lt;math&gt;k&lt;/math&gt;th of &lt;math&gt;n!&lt;/math&gt; permutations in this see quence, for inputs &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. For efficiency it should not construct the first &lt;math&gt;k - 1&lt;/math permutations in the process.
[[9.5|Solution]]

===Backtracking===

:9.6


:[[9.7]]


:9.8


:[[9.9]]


:9.10


:[[9.11]]


:9.12


:[[9.13]]


:9.14


:[[9.15]]


===Games and Puzzles===

:9.16


:[[9.17]]


:9.18


:[[9.19]]


:9.20


===Combinatorial Optimization=== 

:[[9.21]]


:9.22


:[[9.23]]


:9.24


:[[9.25]]


:9.26


:[[9.27]]


===Interview Problems===

:9.28


:[[9.27]]


:9.28


:[[9.29]]


:9.30


:[[9.31]]


:9.32


:[[9.33]]


Back to [[Chapter List]]</text>
      <sha1>gwc5euyqa7rwu9u5dp160bkdid9g870</sha1>
    </revision>
    <revision>
      <id>225</id>
      <parentid>224</parentid>
      <timestamp>2020-09-13T21:26:47Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Backtracking */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="6061">=Combinatorial Search=

===Permutations===

:[[9.1]]. A ''derangement'' is a permutation &lt;math&gt;p&lt;/math&gt; of &lt;math&gt;{1, . . . , n}&lt;/math&gt; such that no item is in its proper position, that is, &lt;math&gt;p_i 6= i&lt;/math&gt; for all &lt;math&gt;1 \leq i \leq n&lt;/math&gt;. Write an efficient backtracking program with pruning that constructs all the derangements of &lt;math&gt;n&lt;/math&gt; items.
[[9.1|Soluiton]]


:9.2. ''Multisets'' are allowed to have repeated elements. A multiset of n items may thus have fewer than &lt;math&gt;n!&lt;/math&gt; distinct permutations. For example, {1, 1, 2, 2} has only six distinct permutations: [1, 1, 2, 2], [1, 2, 1, 2], [1, 2, 2, 1], [2, 1, 1, 2], [2, 1, 2, 1], and [2, 2, 1, 1]. Design and implement an efficient algorithm for constructing all permutations of a multiset.


:[[9.3]]. For a given a positive integer &lt;math&gt;n&lt;/math&gt;, find all permutations of the &lt;math&gt;2n&lt;/math&gt; elements of the multiset &lt;math&gt;S = {1, 1, 2, 2, 3, 3, . . . , n, n}&lt;/math&gt; such that for each integer from 1 to &lt;math&gt;n&lt;/math&gt; the number of intervening elements between its two appearances is equal to value of the element. For example, when &lt;math&gt;n = 3&lt;/math&gt; the two possible solutions are [3, 1, 2, 1, 3, 2] and [2, 3, 1, 2, 1, 3].
[[9.3|Solution]]


:9.4. Design and implement an algorithm for testing whether two graphs are isomorphic. The graph isomorphism problem is discussed in Section 19.9 (page 610). With proper pruning, graphs on hundreds of vertices can be tested in a reasonable time.


:[[9.5]]. The set &lt;math&gt;{1, 2, 3, ..., n}&lt;/math&gt; contains a total of &lt;math&gt;n!&lt;/math&gt; distinct permutations. By listing and labeling all of the permutations in ascending lexicographic order, we get the following sequence for &lt;math&gt;n = 3&lt;/math&gt;: 
&lt;center&gt;&lt;math&gt;[123, 132, 213, 231, 312, 321]&lt;/math&gt;&lt;/center&gt;
:Give an efficient algorithm that returns the &lt;math&gt;k&lt;/math&gt;th of &lt;math&gt;n!&lt;/math&gt; permutations in this see quence, for inputs &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. For efficiency it should not construct the first &lt;math&gt;k - 1&lt;/math permutations in the process.
[[9.5|Solution]]

===Backtracking===

:9.6. Generate all structurally distinct binary search trees that store values &lt;math&gt;1 . . . n&lt;/math&gt;, for a given value of &lt;math&gt;n&lt;/math&gt;.


:[[9.7]]. Implement an algorithm to print all valid (meaning properly opened and closed) sequences of n pairs of parentheses.
[[9.7|Solution]]


:9.8. Generate all possible topological orderings of a given DAG.


:[[9.9]]. Given a specified total t and a multiset &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find all distinct subsets from &lt;math&gt;S&lt;/math&gt; whose elements add up to &lt;math&gt;t&lt;/math&gt;. For example, if &lt;math&gt;t = 4&lt;/math&gt; and &lt;math&gt;S = {4, 3, 2, 2, 1, 1}&lt;/math&gt;, then there are four different sums that equal &lt;math&gt;t: 4, 3 + 1, 2 + 2&lt;/math&gt;, and &lt;math&gt;2 + 1 + 1&lt;/math&gt;. A number can be used within a sum up to the number of times it appears in &lt;math&gt;S&lt;/math&gt;, and a single number counts as a sum.
[[9.9|Solution]]


:9.10. Given a specified total &lt;math&gt;t&lt;/math&gt; and a multiset &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find all distinct subsets from &lt;math&gt;S&lt;/math&gt; whose elements add up to &lt;math&gt;t&lt;/math&gt;. For example, if &lt;math&gt;t = 4&lt;/math&gt; and &lt;math&gt;S = {4, 3, 2, 2, 1, 1}&lt;/math&gt;, then there are four different sums that equal &lt;math&gt;t: 4, 3 + 1, 2 + 2&lt;/math&gt;, and &lt;math&gt;2 + 1 + 1&lt;/math&gt;. A number can be used within a sum up to the number of times it appears in &lt;math&gt;S&lt;/math&gt;, and a single number counts as a sum.


:[[9.11]]. A team assignment of &lt;math&gt;n = 2k&lt;/math&gt; players is a partitioning of them into two teams with exactly &lt;math&gt;k&lt;/math&gt; people per team. For example, if the players are named &lt;math&gt;{A, B, C, D}&lt;/math&gt;, there are three distinct ways to partition them into two equal teams: &lt;math&gt;{{A, B}, {C, D}}, {{A, C}, {B, D}}, and {{A, D}, {B, C}}&lt;/math&gt;. 
:(a) List the 10 possible team assignments for &lt;math&gt;n = 6&lt;/math&gt; players.
:(b) Give an efficient back-tracking algorithm to construct all possible team assignments. Be sure to avoid repeating any solution.
[[9.11|Solution]]


:9.12. Given an alphabet &lt;math&gt;\Sigma&lt;/math&gt;, a set of forbidden strings &lt;math&gt;S&lt;/math&gt;, and a target length &lt;math&gt;n&lt;/math&gt;, give an algorithm to construct a string of length &lt;math&gt;n&lt;/math&gt; on &lt;math&gt;\Sigma&lt;/math&gt; without any element of &lt;math&gt;S&lt;/math&gt; as a substring. For &lt;math&gt;\Sigma = {0, 1}, S = {01, 10}&lt;math&gt;, and &lt;math&gt;n = 4&lt;/math&gt;, the two possible solutions are 0000 and 1111. For &lt;math&gt;S = {0, 11}&lt;/math&gt; and &lt;math&gt;n = 4&lt;/math&gt;, no such string exists.


:[[9.13]]. In the &lt;math&gt;k&lt;/math&gt;-partition problem, we need to partition a multiset of positive integers into &lt;math&gt;k&lt;/math&gt; disjoint subsets that have equal sum. Design and implement an algorithm for solving the &lt;math&gt;k&lt;/math&gt;-partition problem.
[[9.13|Solution]]


:9.14. You are given a weighted directed graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges. The mean weight of a cycle is the sum of its edge weights divided by the number of its edges. Find a cycle in &lt;math&gt;G&lt;/math&gt; of minimum mean weight.


:[[9.15]]. In the turnpike reconstruction problem, you are given a multiset &lt;math&gt;D&lt;/math&gt; of &lt;math&gt;n(n - 1)/2&lt;/math&gt; distances. The problem is to place &lt;math&gt;n&lt;/math&gt; points on the line such that their pairwise distances are &lt;math&gt;D&lt;/math&gt;. For example, the distances &lt;math&gt;D = {1, 2, 3, 4, 5, 6}&lt;/math&gt; can be obtained by placing the second point 1 unit from the first, the third point 3 from the second, and the fourth point 2 from the third. Design and implement an efficient algorithm to find all solutions to the turnpike reconstruction problem. Exploit additive constraints when possible to accelerate the search. With proper pruning, problems with hundreds of points can be solved in reasonable time.
[[9.15|Solution]]

===Games and Puzzles===

:9.16


:[[9.17]]


:9.18


:[[9.19]]


:9.20


===Combinatorial Optimization=== 

:[[9.21]]


:9.22


:[[9.23]]


:9.24


:[[9.25]]


:9.26


:[[9.27]]


===Interview Problems===

:9.28


:[[9.27]]


:9.28


:[[9.29]]


:9.30


:[[9.31]]


:9.32


:[[9.33]]


Back to [[Chapter List]]</text>
      <sha1>bl86t1pl08fvonw83s1mp6013ektmvi</sha1>
    </revision>
    <revision>
      <id>226</id>
      <parentid>225</parentid>
      <timestamp>2020-09-13T21:36:32Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Games and Puzzles */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="7804">=Combinatorial Search=

===Permutations===

:[[9.1]]. A ''derangement'' is a permutation &lt;math&gt;p&lt;/math&gt; of &lt;math&gt;{1, . . . , n}&lt;/math&gt; such that no item is in its proper position, that is, &lt;math&gt;p_i 6= i&lt;/math&gt; for all &lt;math&gt;1 \leq i \leq n&lt;/math&gt;. Write an efficient backtracking program with pruning that constructs all the derangements of &lt;math&gt;n&lt;/math&gt; items.
[[9.1|Soluiton]]


:9.2. ''Multisets'' are allowed to have repeated elements. A multiset of n items may thus have fewer than &lt;math&gt;n!&lt;/math&gt; distinct permutations. For example, {1, 1, 2, 2} has only six distinct permutations: [1, 1, 2, 2], [1, 2, 1, 2], [1, 2, 2, 1], [2, 1, 1, 2], [2, 1, 2, 1], and [2, 2, 1, 1]. Design and implement an efficient algorithm for constructing all permutations of a multiset.


:[[9.3]]. For a given a positive integer &lt;math&gt;n&lt;/math&gt;, find all permutations of the &lt;math&gt;2n&lt;/math&gt; elements of the multiset &lt;math&gt;S = {1, 1, 2, 2, 3, 3, . . . , n, n}&lt;/math&gt; such that for each integer from 1 to &lt;math&gt;n&lt;/math&gt; the number of intervening elements between its two appearances is equal to value of the element. For example, when &lt;math&gt;n = 3&lt;/math&gt; the two possible solutions are [3, 1, 2, 1, 3, 2] and [2, 3, 1, 2, 1, 3].
[[9.3|Solution]]


:9.4. Design and implement an algorithm for testing whether two graphs are isomorphic. The graph isomorphism problem is discussed in Section 19.9 (page 610). With proper pruning, graphs on hundreds of vertices can be tested in a reasonable time.


:[[9.5]]. The set &lt;math&gt;{1, 2, 3, ..., n}&lt;/math&gt; contains a total of &lt;math&gt;n!&lt;/math&gt; distinct permutations. By listing and labeling all of the permutations in ascending lexicographic order, we get the following sequence for &lt;math&gt;n = 3&lt;/math&gt;: 
&lt;center&gt;&lt;math&gt;[123, 132, 213, 231, 312, 321]&lt;/math&gt;&lt;/center&gt;
:Give an efficient algorithm that returns the &lt;math&gt;k&lt;/math&gt;th of &lt;math&gt;n!&lt;/math&gt; permutations in this see quence, for inputs &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. For efficiency it should not construct the first &lt;math&gt;k - 1&lt;/math permutations in the process.
[[9.5|Solution]]

===Backtracking===

:9.6. Generate all structurally distinct binary search trees that store values &lt;math&gt;1 . . . n&lt;/math&gt;, for a given value of &lt;math&gt;n&lt;/math&gt;.


:[[9.7]]. Implement an algorithm to print all valid (meaning properly opened and closed) sequences of n pairs of parentheses.
[[9.7|Solution]]


:9.8. Generate all possible topological orderings of a given DAG.


:[[9.9]]. Given a specified total t and a multiset &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find all distinct subsets from &lt;math&gt;S&lt;/math&gt; whose elements add up to &lt;math&gt;t&lt;/math&gt;. For example, if &lt;math&gt;t = 4&lt;/math&gt; and &lt;math&gt;S = {4, 3, 2, 2, 1, 1}&lt;/math&gt;, then there are four different sums that equal &lt;math&gt;t: 4, 3 + 1, 2 + 2&lt;/math&gt;, and &lt;math&gt;2 + 1 + 1&lt;/math&gt;. A number can be used within a sum up to the number of times it appears in &lt;math&gt;S&lt;/math&gt;, and a single number counts as a sum.
[[9.9|Solution]]


:9.10. Given a specified total &lt;math&gt;t&lt;/math&gt; and a multiset &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find all distinct subsets from &lt;math&gt;S&lt;/math&gt; whose elements add up to &lt;math&gt;t&lt;/math&gt;. For example, if &lt;math&gt;t = 4&lt;/math&gt; and &lt;math&gt;S = {4, 3, 2, 2, 1, 1}&lt;/math&gt;, then there are four different sums that equal &lt;math&gt;t: 4, 3 + 1, 2 + 2&lt;/math&gt;, and &lt;math&gt;2 + 1 + 1&lt;/math&gt;. A number can be used within a sum up to the number of times it appears in &lt;math&gt;S&lt;/math&gt;, and a single number counts as a sum.


:[[9.11]]. A team assignment of &lt;math&gt;n = 2k&lt;/math&gt; players is a partitioning of them into two teams with exactly &lt;math&gt;k&lt;/math&gt; people per team. For example, if the players are named &lt;math&gt;{A, B, C, D}&lt;/math&gt;, there are three distinct ways to partition them into two equal teams: &lt;math&gt;{{A, B}, {C, D}}, {{A, C}, {B, D}}, and {{A, D}, {B, C}}&lt;/math&gt;. 
:(a) List the 10 possible team assignments for &lt;math&gt;n = 6&lt;/math&gt; players.
:(b) Give an efficient back-tracking algorithm to construct all possible team assignments. Be sure to avoid repeating any solution.
[[9.11|Solution]]


:9.12. Given an alphabet &lt;math&gt;\Sigma&lt;/math&gt;, a set of forbidden strings &lt;math&gt;S&lt;/math&gt;, and a target length &lt;math&gt;n&lt;/math&gt;, give an algorithm to construct a string of length &lt;math&gt;n&lt;/math&gt; on &lt;math&gt;\Sigma&lt;/math&gt; without any element of &lt;math&gt;S&lt;/math&gt; as a substring. For &lt;math&gt;\Sigma = {0, 1}, S = {01, 10}&lt;math&gt;, and &lt;math&gt;n = 4&lt;/math&gt;, the two possible solutions are 0000 and 1111. For &lt;math&gt;S = {0, 11}&lt;/math&gt; and &lt;math&gt;n = 4&lt;/math&gt;, no such string exists.


:[[9.13]]. In the &lt;math&gt;k&lt;/math&gt;-partition problem, we need to partition a multiset of positive integers into &lt;math&gt;k&lt;/math&gt; disjoint subsets that have equal sum. Design and implement an algorithm for solving the &lt;math&gt;k&lt;/math&gt;-partition problem.
[[9.13|Solution]]


:9.14. You are given a weighted directed graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges. The mean weight of a cycle is the sum of its edge weights divided by the number of its edges. Find a cycle in &lt;math&gt;G&lt;/math&gt; of minimum mean weight.


:[[9.15]]. In the turnpike reconstruction problem, you are given a multiset &lt;math&gt;D&lt;/math&gt; of &lt;math&gt;n(n - 1)/2&lt;/math&gt; distances. The problem is to place &lt;math&gt;n&lt;/math&gt; points on the line such that their pairwise distances are &lt;math&gt;D&lt;/math&gt;. For example, the distances &lt;math&gt;D = {1, 2, 3, 4, 5, 6}&lt;/math&gt; can be obtained by placing the second point 1 unit from the first, the third point 3 from the second, and the fourth point 2 from the third. Design and implement an efficient algorithm to find all solutions to the turnpike reconstruction problem. Exploit additive constraints when possible to accelerate the search. With proper pruning, problems with hundreds of points can be solved in reasonable time.
[[9.15|Solution]]

===Games and Puzzles===

:9.16. Anagrams are rearrangements of the letters of a word or phrase into a different word or phrase. Sometimes the results are quite striking. For example, “MANY VOTED BUSH RETIRED” is an anagram of “TUESDAY NOVEMBER THIRD,” which correctly predicted the result of the 1992 US presidential election. Design and implement an algorithm for finding anagrams using combinatorial search and a dictionary.


:[[9.17]]. Construct all sequences of moves that a knight on an &lt;math&gt;n * n&lt;/math&gt; chessboard can make where the knight visits every square only once.
[[9.17|Solution]]


:9.18. A Boggle board is an &lt;math&gt;n * m&lt;/math&gt; grid of characters. For a given board, we seek to find all possible words that can be formed by a sequence of adjacent characters on the board, without repetition. For example, the board:
&lt;center&gt;&lt;math&gt;\begin{matrix}
e &amp; t &amp; h &amp; t\\
n &amp; d &amp; t &amp; i\\
a &amp; i &amp; h &amp; n\\
r &amp; h &amp; u &amp; b
\end{matrix}&lt;/math&gt;&lt;/center&gt;
:contains words like tide, dent, raid, and hide. Design an algorithm to construct the most words for a given board &lt;math&gt;B&lt;/math&gt; consistent with a dictionary &lt;math&gt;D&lt;/math&gt;.


:[[9.19]]. A Babbage square is a grid of words that reads the same across as it does down. Given a &lt;math&gt;k&lt;/math&gt;-letter word &lt;math&gt;w&lt;/math&gt; and a dictionary of &lt;math&gt;n&lt;/math&gt; words, find all Babbage squares starting with that word. For example, two squares for the word hair are:
&lt;center&gt;&lt;math&gt;\begin{vmatrix}
h &amp; a &amp; i &amp; r\\
a &amp; i &amp; d &amp; e\\
i &amp; d &amp; l &amp; e\\
r &amp; e &amp; e &amp; f
\end{vmatrix}\begin{vmatrix}
h &amp; a &amp; i &amp; r\\
a &amp; l &amp; t &amp; o\\
i &amp; t &amp; e &amp; m\\
r &amp; o &amp; m &amp; b
\end{vmatrix}
&lt;/math&gt;&lt;/center&gt;
[[9.19|Solution]]


:9.20. Show that you can solve any given Sudoku puzzle by finding the minimum vertex coloring of a specific, appropriately constructed 9 × 9 + 9 vertex graph.

===Combinatorial Optimization=== 

:[[9.21]]


:9.22


:[[9.23]]


:9.24


:[[9.25]]


:9.26


:[[9.27]]


===Interview Problems===

:9.28


:[[9.27]]


:9.28


:[[9.29]]


:9.30


:[[9.31]]


:9.32


:[[9.33]]


Back to [[Chapter List]]</text>
      <sha1>gbctmsk0ao2cqjbxm8l6j9vm5xdnqk4</sha1>
    </revision>
    <revision>
      <id>227</id>
      <parentid>226</parentid>
      <timestamp>2020-09-13T21:37:05Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Permutations */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="7805">=Combinatorial Search=

===Permutations===

:[[9.1]]. A ''derangement'' is a permutation &lt;math&gt;p&lt;/math&gt; of &lt;math&gt;{1, . . . , n}&lt;/math&gt; such that no item is in its proper position, that is, &lt;math&gt;p_i 6= i&lt;/math&gt; for all &lt;math&gt;1 \leq i \leq n&lt;/math&gt;. Write an efficient backtracking program with pruning that constructs all the derangements of &lt;math&gt;n&lt;/math&gt; items.
[[9.1|Soluiton]]


:9.2. ''Multisets'' are allowed to have repeated elements. A multiset of n items may thus have fewer than &lt;math&gt;n!&lt;/math&gt; distinct permutations. For example, {1, 1, 2, 2} has only six distinct permutations: [1, 1, 2, 2], [1, 2, 1, 2], [1, 2, 2, 1], [2, 1, 1, 2], [2, 1, 2, 1], and [2, 2, 1, 1]. Design and implement an efficient algorithm for constructing all permutations of a multiset.


:[[9.3]]. For a given a positive integer &lt;math&gt;n&lt;/math&gt;, find all permutations of the &lt;math&gt;2n&lt;/math&gt; elements of the multiset &lt;math&gt;S = {1, 1, 2, 2, 3, 3, . . . , n, n}&lt;/math&gt; such that for each integer from 1 to &lt;math&gt;n&lt;/math&gt; the number of intervening elements between its two appearances is equal to value of the element. For example, when &lt;math&gt;n = 3&lt;/math&gt; the two possible solutions are [3, 1, 2, 1, 3, 2] and [2, 3, 1, 2, 1, 3].
[[9.3|Solution]]


:9.4. Design and implement an algorithm for testing whether two graphs are isomorphic. The graph isomorphism problem is discussed in Section 19.9 (page 610). With proper pruning, graphs on hundreds of vertices can be tested in a reasonable time.


:[[9.5]]. The set &lt;math&gt;{1, 2, 3, ..., n}&lt;/math&gt; contains a total of &lt;math&gt;n!&lt;/math&gt; distinct permutations. By listing and labeling all of the permutations in ascending lexicographic order, we get the following sequence for &lt;math&gt;n = 3&lt;/math&gt;: 
&lt;center&gt;&lt;math&gt;[123, 132, 213, 231, 312, 321]&lt;/math&gt;&lt;/center&gt;
:Give an efficient algorithm that returns the &lt;math&gt;k&lt;/math&gt;th of &lt;math&gt;n!&lt;/math&gt; permutations in this see quence, for inputs &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. For efficiency it should not construct the first &lt;math&gt;k - 1&lt;/math&gt; permutations in the process.
[[9.5|Solution]]

===Backtracking===

:9.6. Generate all structurally distinct binary search trees that store values &lt;math&gt;1 . . . n&lt;/math&gt;, for a given value of &lt;math&gt;n&lt;/math&gt;.


:[[9.7]]. Implement an algorithm to print all valid (meaning properly opened and closed) sequences of n pairs of parentheses.
[[9.7|Solution]]


:9.8. Generate all possible topological orderings of a given DAG.


:[[9.9]]. Given a specified total t and a multiset &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find all distinct subsets from &lt;math&gt;S&lt;/math&gt; whose elements add up to &lt;math&gt;t&lt;/math&gt;. For example, if &lt;math&gt;t = 4&lt;/math&gt; and &lt;math&gt;S = {4, 3, 2, 2, 1, 1}&lt;/math&gt;, then there are four different sums that equal &lt;math&gt;t: 4, 3 + 1, 2 + 2&lt;/math&gt;, and &lt;math&gt;2 + 1 + 1&lt;/math&gt;. A number can be used within a sum up to the number of times it appears in &lt;math&gt;S&lt;/math&gt;, and a single number counts as a sum.
[[9.9|Solution]]


:9.10. Given a specified total &lt;math&gt;t&lt;/math&gt; and a multiset &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find all distinct subsets from &lt;math&gt;S&lt;/math&gt; whose elements add up to &lt;math&gt;t&lt;/math&gt;. For example, if &lt;math&gt;t = 4&lt;/math&gt; and &lt;math&gt;S = {4, 3, 2, 2, 1, 1}&lt;/math&gt;, then there are four different sums that equal &lt;math&gt;t: 4, 3 + 1, 2 + 2&lt;/math&gt;, and &lt;math&gt;2 + 1 + 1&lt;/math&gt;. A number can be used within a sum up to the number of times it appears in &lt;math&gt;S&lt;/math&gt;, and a single number counts as a sum.


:[[9.11]]. A team assignment of &lt;math&gt;n = 2k&lt;/math&gt; players is a partitioning of them into two teams with exactly &lt;math&gt;k&lt;/math&gt; people per team. For example, if the players are named &lt;math&gt;{A, B, C, D}&lt;/math&gt;, there are three distinct ways to partition them into two equal teams: &lt;math&gt;{{A, B}, {C, D}}, {{A, C}, {B, D}}, and {{A, D}, {B, C}}&lt;/math&gt;. 
:(a) List the 10 possible team assignments for &lt;math&gt;n = 6&lt;/math&gt; players.
:(b) Give an efficient back-tracking algorithm to construct all possible team assignments. Be sure to avoid repeating any solution.
[[9.11|Solution]]


:9.12. Given an alphabet &lt;math&gt;\Sigma&lt;/math&gt;, a set of forbidden strings &lt;math&gt;S&lt;/math&gt;, and a target length &lt;math&gt;n&lt;/math&gt;, give an algorithm to construct a string of length &lt;math&gt;n&lt;/math&gt; on &lt;math&gt;\Sigma&lt;/math&gt; without any element of &lt;math&gt;S&lt;/math&gt; as a substring. For &lt;math&gt;\Sigma = {0, 1}, S = {01, 10}&lt;math&gt;, and &lt;math&gt;n = 4&lt;/math&gt;, the two possible solutions are 0000 and 1111. For &lt;math&gt;S = {0, 11}&lt;/math&gt; and &lt;math&gt;n = 4&lt;/math&gt;, no such string exists.


:[[9.13]]. In the &lt;math&gt;k&lt;/math&gt;-partition problem, we need to partition a multiset of positive integers into &lt;math&gt;k&lt;/math&gt; disjoint subsets that have equal sum. Design and implement an algorithm for solving the &lt;math&gt;k&lt;/math&gt;-partition problem.
[[9.13|Solution]]


:9.14. You are given a weighted directed graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges. The mean weight of a cycle is the sum of its edge weights divided by the number of its edges. Find a cycle in &lt;math&gt;G&lt;/math&gt; of minimum mean weight.


:[[9.15]]. In the turnpike reconstruction problem, you are given a multiset &lt;math&gt;D&lt;/math&gt; of &lt;math&gt;n(n - 1)/2&lt;/math&gt; distances. The problem is to place &lt;math&gt;n&lt;/math&gt; points on the line such that their pairwise distances are &lt;math&gt;D&lt;/math&gt;. For example, the distances &lt;math&gt;D = {1, 2, 3, 4, 5, 6}&lt;/math&gt; can be obtained by placing the second point 1 unit from the first, the third point 3 from the second, and the fourth point 2 from the third. Design and implement an efficient algorithm to find all solutions to the turnpike reconstruction problem. Exploit additive constraints when possible to accelerate the search. With proper pruning, problems with hundreds of points can be solved in reasonable time.
[[9.15|Solution]]

===Games and Puzzles===

:9.16. Anagrams are rearrangements of the letters of a word or phrase into a different word or phrase. Sometimes the results are quite striking. For example, “MANY VOTED BUSH RETIRED” is an anagram of “TUESDAY NOVEMBER THIRD,” which correctly predicted the result of the 1992 US presidential election. Design and implement an algorithm for finding anagrams using combinatorial search and a dictionary.


:[[9.17]]. Construct all sequences of moves that a knight on an &lt;math&gt;n * n&lt;/math&gt; chessboard can make where the knight visits every square only once.
[[9.17|Solution]]


:9.18. A Boggle board is an &lt;math&gt;n * m&lt;/math&gt; grid of characters. For a given board, we seek to find all possible words that can be formed by a sequence of adjacent characters on the board, without repetition. For example, the board:
&lt;center&gt;&lt;math&gt;\begin{matrix}
e &amp; t &amp; h &amp; t\\
n &amp; d &amp; t &amp; i\\
a &amp; i &amp; h &amp; n\\
r &amp; h &amp; u &amp; b
\end{matrix}&lt;/math&gt;&lt;/center&gt;
:contains words like tide, dent, raid, and hide. Design an algorithm to construct the most words for a given board &lt;math&gt;B&lt;/math&gt; consistent with a dictionary &lt;math&gt;D&lt;/math&gt;.


:[[9.19]]. A Babbage square is a grid of words that reads the same across as it does down. Given a &lt;math&gt;k&lt;/math&gt;-letter word &lt;math&gt;w&lt;/math&gt; and a dictionary of &lt;math&gt;n&lt;/math&gt; words, find all Babbage squares starting with that word. For example, two squares for the word hair are:
&lt;center&gt;&lt;math&gt;\begin{vmatrix}
h &amp; a &amp; i &amp; r\\
a &amp; i &amp; d &amp; e\\
i &amp; d &amp; l &amp; e\\
r &amp; e &amp; e &amp; f
\end{vmatrix}\begin{vmatrix}
h &amp; a &amp; i &amp; r\\
a &amp; l &amp; t &amp; o\\
i &amp; t &amp; e &amp; m\\
r &amp; o &amp; m &amp; b
\end{vmatrix}
&lt;/math&gt;&lt;/center&gt;
[[9.19|Solution]]


:9.20. Show that you can solve any given Sudoku puzzle by finding the minimum vertex coloring of a specific, appropriately constructed 9 × 9 + 9 vertex graph.

===Combinatorial Optimization=== 

:[[9.21]]


:9.22


:[[9.23]]


:9.24


:[[9.25]]


:9.26


:[[9.27]]


===Interview Problems===

:9.28


:[[9.27]]


:9.28


:[[9.29]]


:9.30


:[[9.31]]


:9.32


:[[9.33]]


Back to [[Chapter List]]</text>
      <sha1>f1fljfhjxkdxz3ktth8w59hedikgv5u</sha1>
    </revision>
    <revision>
      <id>229</id>
      <parentid>227</parentid>
      <timestamp>2020-09-13T21:40:49Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Combinatorial Optimization */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="8851">=Combinatorial Search=

===Permutations===

:[[9.1]]. A ''derangement'' is a permutation &lt;math&gt;p&lt;/math&gt; of &lt;math&gt;{1, . . . , n}&lt;/math&gt; such that no item is in its proper position, that is, &lt;math&gt;p_i 6= i&lt;/math&gt; for all &lt;math&gt;1 \leq i \leq n&lt;/math&gt;. Write an efficient backtracking program with pruning that constructs all the derangements of &lt;math&gt;n&lt;/math&gt; items.
[[9.1|Soluiton]]


:9.2. ''Multisets'' are allowed to have repeated elements. A multiset of n items may thus have fewer than &lt;math&gt;n!&lt;/math&gt; distinct permutations. For example, {1, 1, 2, 2} has only six distinct permutations: [1, 1, 2, 2], [1, 2, 1, 2], [1, 2, 2, 1], [2, 1, 1, 2], [2, 1, 2, 1], and [2, 2, 1, 1]. Design and implement an efficient algorithm for constructing all permutations of a multiset.


:[[9.3]]. For a given a positive integer &lt;math&gt;n&lt;/math&gt;, find all permutations of the &lt;math&gt;2n&lt;/math&gt; elements of the multiset &lt;math&gt;S = {1, 1, 2, 2, 3, 3, . . . , n, n}&lt;/math&gt; such that for each integer from 1 to &lt;math&gt;n&lt;/math&gt; the number of intervening elements between its two appearances is equal to value of the element. For example, when &lt;math&gt;n = 3&lt;/math&gt; the two possible solutions are [3, 1, 2, 1, 3, 2] and [2, 3, 1, 2, 1, 3].
[[9.3|Solution]]


:9.4. Design and implement an algorithm for testing whether two graphs are isomorphic. The graph isomorphism problem is discussed in Section 19.9 (page 610). With proper pruning, graphs on hundreds of vertices can be tested in a reasonable time.


:[[9.5]]. The set &lt;math&gt;{1, 2, 3, ..., n}&lt;/math&gt; contains a total of &lt;math&gt;n!&lt;/math&gt; distinct permutations. By listing and labeling all of the permutations in ascending lexicographic order, we get the following sequence for &lt;math&gt;n = 3&lt;/math&gt;: 
&lt;center&gt;&lt;math&gt;[123, 132, 213, 231, 312, 321]&lt;/math&gt;&lt;/center&gt;
:Give an efficient algorithm that returns the &lt;math&gt;k&lt;/math&gt;th of &lt;math&gt;n!&lt;/math&gt; permutations in this see quence, for inputs &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. For efficiency it should not construct the first &lt;math&gt;k - 1&lt;/math&gt; permutations in the process.
[[9.5|Solution]]

===Backtracking===

:9.6. Generate all structurally distinct binary search trees that store values &lt;math&gt;1 . . . n&lt;/math&gt;, for a given value of &lt;math&gt;n&lt;/math&gt;.


:[[9.7]]. Implement an algorithm to print all valid (meaning properly opened and closed) sequences of n pairs of parentheses.
[[9.7|Solution]]


:9.8. Generate all possible topological orderings of a given DAG.


:[[9.9]]. Given a specified total t and a multiset &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find all distinct subsets from &lt;math&gt;S&lt;/math&gt; whose elements add up to &lt;math&gt;t&lt;/math&gt;. For example, if &lt;math&gt;t = 4&lt;/math&gt; and &lt;math&gt;S = {4, 3, 2, 2, 1, 1}&lt;/math&gt;, then there are four different sums that equal &lt;math&gt;t: 4, 3 + 1, 2 + 2&lt;/math&gt;, and &lt;math&gt;2 + 1 + 1&lt;/math&gt;. A number can be used within a sum up to the number of times it appears in &lt;math&gt;S&lt;/math&gt;, and a single number counts as a sum.
[[9.9|Solution]]


:9.10. Given a specified total &lt;math&gt;t&lt;/math&gt; and a multiset &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find all distinct subsets from &lt;math&gt;S&lt;/math&gt; whose elements add up to &lt;math&gt;t&lt;/math&gt;. For example, if &lt;math&gt;t = 4&lt;/math&gt; and &lt;math&gt;S = {4, 3, 2, 2, 1, 1}&lt;/math&gt;, then there are four different sums that equal &lt;math&gt;t: 4, 3 + 1, 2 + 2&lt;/math&gt;, and &lt;math&gt;2 + 1 + 1&lt;/math&gt;. A number can be used within a sum up to the number of times it appears in &lt;math&gt;S&lt;/math&gt;, and a single number counts as a sum.


:[[9.11]]. A team assignment of &lt;math&gt;n = 2k&lt;/math&gt; players is a partitioning of them into two teams with exactly &lt;math&gt;k&lt;/math&gt; people per team. For example, if the players are named &lt;math&gt;{A, B, C, D}&lt;/math&gt;, there are three distinct ways to partition them into two equal teams: &lt;math&gt;{{A, B}, {C, D}}, {{A, C}, {B, D}}, and {{A, D}, {B, C}}&lt;/math&gt;. 
:(a) List the 10 possible team assignments for &lt;math&gt;n = 6&lt;/math&gt; players.
:(b) Give an efficient back-tracking algorithm to construct all possible team assignments. Be sure to avoid repeating any solution.
[[9.11|Solution]]


:9.12. Given an alphabet &lt;math&gt;\Sigma&lt;/math&gt;, a set of forbidden strings &lt;math&gt;S&lt;/math&gt;, and a target length &lt;math&gt;n&lt;/math&gt;, give an algorithm to construct a string of length &lt;math&gt;n&lt;/math&gt; on &lt;math&gt;\Sigma&lt;/math&gt; without any element of &lt;math&gt;S&lt;/math&gt; as a substring. For &lt;math&gt;\Sigma = {0, 1}, S = {01, 10}&lt;math&gt;, and &lt;math&gt;n = 4&lt;/math&gt;, the two possible solutions are 0000 and 1111. For &lt;math&gt;S = {0, 11}&lt;/math&gt; and &lt;math&gt;n = 4&lt;/math&gt;, no such string exists.


:[[9.13]]. In the &lt;math&gt;k&lt;/math&gt;-partition problem, we need to partition a multiset of positive integers into &lt;math&gt;k&lt;/math&gt; disjoint subsets that have equal sum. Design and implement an algorithm for solving the &lt;math&gt;k&lt;/math&gt;-partition problem.
[[9.13|Solution]]


:9.14. You are given a weighted directed graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges. The mean weight of a cycle is the sum of its edge weights divided by the number of its edges. Find a cycle in &lt;math&gt;G&lt;/math&gt; of minimum mean weight.


:[[9.15]]. In the turnpike reconstruction problem, you are given a multiset &lt;math&gt;D&lt;/math&gt; of &lt;math&gt;n(n - 1)/2&lt;/math&gt; distances. The problem is to place &lt;math&gt;n&lt;/math&gt; points on the line such that their pairwise distances are &lt;math&gt;D&lt;/math&gt;. For example, the distances &lt;math&gt;D = {1, 2, 3, 4, 5, 6}&lt;/math&gt; can be obtained by placing the second point 1 unit from the first, the third point 3 from the second, and the fourth point 2 from the third. Design and implement an efficient algorithm to find all solutions to the turnpike reconstruction problem. Exploit additive constraints when possible to accelerate the search. With proper pruning, problems with hundreds of points can be solved in reasonable time.
[[9.15|Solution]]

===Games and Puzzles===

:9.16. Anagrams are rearrangements of the letters of a word or phrase into a different word or phrase. Sometimes the results are quite striking. For example, “MANY VOTED BUSH RETIRED” is an anagram of “TUESDAY NOVEMBER THIRD,” which correctly predicted the result of the 1992 US presidential election. Design and implement an algorithm for finding anagrams using combinatorial search and a dictionary.


:[[9.17]]. Construct all sequences of moves that a knight on an &lt;math&gt;n * n&lt;/math&gt; chessboard can make where the knight visits every square only once.
[[9.17|Solution]]


:9.18. A Boggle board is an &lt;math&gt;n * m&lt;/math&gt; grid of characters. For a given board, we seek to find all possible words that can be formed by a sequence of adjacent characters on the board, without repetition. For example, the board:
&lt;center&gt;&lt;math&gt;\begin{matrix}
e &amp; t &amp; h &amp; t\\
n &amp; d &amp; t &amp; i\\
a &amp; i &amp; h &amp; n\\
r &amp; h &amp; u &amp; b
\end{matrix}&lt;/math&gt;&lt;/center&gt;
:contains words like tide, dent, raid, and hide. Design an algorithm to construct the most words for a given board &lt;math&gt;B&lt;/math&gt; consistent with a dictionary &lt;math&gt;D&lt;/math&gt;.


:[[9.19]]. A Babbage square is a grid of words that reads the same across as it does down. Given a &lt;math&gt;k&lt;/math&gt;-letter word &lt;math&gt;w&lt;/math&gt; and a dictionary of &lt;math&gt;n&lt;/math&gt; words, find all Babbage squares starting with that word. For example, two squares for the word hair are:
&lt;center&gt;&lt;math&gt;\begin{vmatrix}
h &amp; a &amp; i &amp; r\\
a &amp; i &amp; d &amp; e\\
i &amp; d &amp; l &amp; e\\
r &amp; e &amp; e &amp; f
\end{vmatrix}\begin{vmatrix}
h &amp; a &amp; i &amp; r\\
a &amp; l &amp; t &amp; o\\
i &amp; t &amp; e &amp; m\\
r &amp; o &amp; m &amp; b
\end{vmatrix}
&lt;/math&gt;&lt;/center&gt;
[[9.19|Solution]]


:9.20. Show that you can solve any given Sudoku puzzle by finding the minimum vertex coloring of a specific, appropriately constructed 9 × 9 + 9 vertex graph.

===Combinatorial Optimization=== 
For problems 9-21 to 9-27, implement a combinatorial search program to solve it for small instances. How well does your program perform in practice?

:[[9.21]]. Design and implement an algorithm for solving the bandwidth minimization problem discussed in Section 16.2 (page 470).
[[9.21|Solution]]


:9.22. Design and implement an algorithm for solving the maximum satisfiability problem discussed in Section 17.10 (page 537).


:[[9.23]]. Design and implement an algorithm for solving the maximum clique problem discussed in Section 19.1 (page 586).
[[9.23|Solution]]


:9.24. Design and implement an algorithm for solving the minimum vertex coloring problem discussed in Section 19.7 (page 604).


:[[9.25]]. Design and implement an algorithm for solving the minimum edge coloring problem discussed in Section 19.8 (page 608).
[[9.25|Solution]]


:9.26. Design and implement an algorithm for solving the minimum feedback vertex set problem discussed in Section 19.11 (page 618).


:[[9.27]]. Design and implement an algorithm for solving the set cover problem discussed in Section 21.1 (page 678).
[[9.27|Solution]]

===Interview Problems===

:9.28


:[[9.27]]


:9.28


:[[9.29]]


:9.30


:[[9.31]]


:9.32


:[[9.33]]


Back to [[Chapter List]]</text>
      <sha1>bmkoru6mlwrqrokqzluuluvee8pyz8d</sha1>
    </revision>
    <revision>
      <id>230</id>
      <parentid>229</parentid>
      <timestamp>2020-09-13T21:59:21Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Interview Problems */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="10028">=Combinatorial Search=

===Permutations===

:[[9.1]]. A ''derangement'' is a permutation &lt;math&gt;p&lt;/math&gt; of &lt;math&gt;{1, . . . , n}&lt;/math&gt; such that no item is in its proper position, that is, &lt;math&gt;p_i 6= i&lt;/math&gt; for all &lt;math&gt;1 \leq i \leq n&lt;/math&gt;. Write an efficient backtracking program with pruning that constructs all the derangements of &lt;math&gt;n&lt;/math&gt; items.
[[9.1|Soluiton]]


:9.2. ''Multisets'' are allowed to have repeated elements. A multiset of n items may thus have fewer than &lt;math&gt;n!&lt;/math&gt; distinct permutations. For example, {1, 1, 2, 2} has only six distinct permutations: [1, 1, 2, 2], [1, 2, 1, 2], [1, 2, 2, 1], [2, 1, 1, 2], [2, 1, 2, 1], and [2, 2, 1, 1]. Design and implement an efficient algorithm for constructing all permutations of a multiset.


:[[9.3]]. For a given a positive integer &lt;math&gt;n&lt;/math&gt;, find all permutations of the &lt;math&gt;2n&lt;/math&gt; elements of the multiset &lt;math&gt;S = {1, 1, 2, 2, 3, 3, . . . , n, n}&lt;/math&gt; such that for each integer from 1 to &lt;math&gt;n&lt;/math&gt; the number of intervening elements between its two appearances is equal to value of the element. For example, when &lt;math&gt;n = 3&lt;/math&gt; the two possible solutions are [3, 1, 2, 1, 3, 2] and [2, 3, 1, 2, 1, 3].
[[9.3|Solution]]


:9.4. Design and implement an algorithm for testing whether two graphs are isomorphic. The graph isomorphism problem is discussed in Section 19.9 (page 610). With proper pruning, graphs on hundreds of vertices can be tested in a reasonable time.


:[[9.5]]. The set &lt;math&gt;{1, 2, 3, ..., n}&lt;/math&gt; contains a total of &lt;math&gt;n!&lt;/math&gt; distinct permutations. By listing and labeling all of the permutations in ascending lexicographic order, we get the following sequence for &lt;math&gt;n = 3&lt;/math&gt;: 
&lt;center&gt;&lt;math&gt;[123, 132, 213, 231, 312, 321]&lt;/math&gt;&lt;/center&gt;
:Give an efficient algorithm that returns the &lt;math&gt;k&lt;/math&gt;th of &lt;math&gt;n!&lt;/math&gt; permutations in this see quence, for inputs &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. For efficiency it should not construct the first &lt;math&gt;k - 1&lt;/math&gt; permutations in the process.
[[9.5|Solution]]

===Backtracking===

:9.6. Generate all structurally distinct binary search trees that store values &lt;math&gt;1 . . . n&lt;/math&gt;, for a given value of &lt;math&gt;n&lt;/math&gt;.


:[[9.7]]. Implement an algorithm to print all valid (meaning properly opened and closed) sequences of n pairs of parentheses.
[[9.7|Solution]]


:9.8. Generate all possible topological orderings of a given DAG.


:[[9.9]]. Given a specified total t and a multiset &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find all distinct subsets from &lt;math&gt;S&lt;/math&gt; whose elements add up to &lt;math&gt;t&lt;/math&gt;. For example, if &lt;math&gt;t = 4&lt;/math&gt; and &lt;math&gt;S = {4, 3, 2, 2, 1, 1}&lt;/math&gt;, then there are four different sums that equal &lt;math&gt;t: 4, 3 + 1, 2 + 2&lt;/math&gt;, and &lt;math&gt;2 + 1 + 1&lt;/math&gt;. A number can be used within a sum up to the number of times it appears in &lt;math&gt;S&lt;/math&gt;, and a single number counts as a sum.
[[9.9|Solution]]


:9.10. Given a specified total &lt;math&gt;t&lt;/math&gt; and a multiset &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find all distinct subsets from &lt;math&gt;S&lt;/math&gt; whose elements add up to &lt;math&gt;t&lt;/math&gt;. For example, if &lt;math&gt;t = 4&lt;/math&gt; and &lt;math&gt;S = {4, 3, 2, 2, 1, 1}&lt;/math&gt;, then there are four different sums that equal &lt;math&gt;t: 4, 3 + 1, 2 + 2&lt;/math&gt;, and &lt;math&gt;2 + 1 + 1&lt;/math&gt;. A number can be used within a sum up to the number of times it appears in &lt;math&gt;S&lt;/math&gt;, and a single number counts as a sum.


:[[9.11]]. A team assignment of &lt;math&gt;n = 2k&lt;/math&gt; players is a partitioning of them into two teams with exactly &lt;math&gt;k&lt;/math&gt; people per team. For example, if the players are named &lt;math&gt;{A, B, C, D}&lt;/math&gt;, there are three distinct ways to partition them into two equal teams: &lt;math&gt;{{A, B}, {C, D}}, {{A, C}, {B, D}}, and {{A, D}, {B, C}}&lt;/math&gt;. 
:(a) List the 10 possible team assignments for &lt;math&gt;n = 6&lt;/math&gt; players.
:(b) Give an efficient back-tracking algorithm to construct all possible team assignments. Be sure to avoid repeating any solution.
[[9.11|Solution]]


:9.12. Given an alphabet &lt;math&gt;\Sigma&lt;/math&gt;, a set of forbidden strings &lt;math&gt;S&lt;/math&gt;, and a target length &lt;math&gt;n&lt;/math&gt;, give an algorithm to construct a string of length &lt;math&gt;n&lt;/math&gt; on &lt;math&gt;\Sigma&lt;/math&gt; without any element of &lt;math&gt;S&lt;/math&gt; as a substring. For &lt;math&gt;\Sigma = {0, 1}, S = {01, 10}&lt;math&gt;, and &lt;math&gt;n = 4&lt;/math&gt;, the two possible solutions are 0000 and 1111. For &lt;math&gt;S = {0, 11}&lt;/math&gt; and &lt;math&gt;n = 4&lt;/math&gt;, no such string exists.


:[[9.13]]. In the &lt;math&gt;k&lt;/math&gt;-partition problem, we need to partition a multiset of positive integers into &lt;math&gt;k&lt;/math&gt; disjoint subsets that have equal sum. Design and implement an algorithm for solving the &lt;math&gt;k&lt;/math&gt;-partition problem.
[[9.13|Solution]]


:9.14. You are given a weighted directed graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges. The mean weight of a cycle is the sum of its edge weights divided by the number of its edges. Find a cycle in &lt;math&gt;G&lt;/math&gt; of minimum mean weight.


:[[9.15]]. In the turnpike reconstruction problem, you are given a multiset &lt;math&gt;D&lt;/math&gt; of &lt;math&gt;n(n - 1)/2&lt;/math&gt; distances. The problem is to place &lt;math&gt;n&lt;/math&gt; points on the line such that their pairwise distances are &lt;math&gt;D&lt;/math&gt;. For example, the distances &lt;math&gt;D = {1, 2, 3, 4, 5, 6}&lt;/math&gt; can be obtained by placing the second point 1 unit from the first, the third point 3 from the second, and the fourth point 2 from the third. Design and implement an efficient algorithm to find all solutions to the turnpike reconstruction problem. Exploit additive constraints when possible to accelerate the search. With proper pruning, problems with hundreds of points can be solved in reasonable time.
[[9.15|Solution]]

===Games and Puzzles===

:9.16. Anagrams are rearrangements of the letters of a word or phrase into a different word or phrase. Sometimes the results are quite striking. For example, “MANY VOTED BUSH RETIRED” is an anagram of “TUESDAY NOVEMBER THIRD,” which correctly predicted the result of the 1992 US presidential election. Design and implement an algorithm for finding anagrams using combinatorial search and a dictionary.


:[[9.17]]. Construct all sequences of moves that a knight on an &lt;math&gt;n * n&lt;/math&gt; chessboard can make where the knight visits every square only once.
[[9.17|Solution]]


:9.18. A Boggle board is an &lt;math&gt;n * m&lt;/math&gt; grid of characters. For a given board, we seek to find all possible words that can be formed by a sequence of adjacent characters on the board, without repetition. For example, the board:
&lt;center&gt;&lt;math&gt;\begin{matrix}
e &amp; t &amp; h &amp; t\\
n &amp; d &amp; t &amp; i\\
a &amp; i &amp; h &amp; n\\
r &amp; h &amp; u &amp; b
\end{matrix}&lt;/math&gt;&lt;/center&gt;
:contains words like tide, dent, raid, and hide. Design an algorithm to construct the most words for a given board &lt;math&gt;B&lt;/math&gt; consistent with a dictionary &lt;math&gt;D&lt;/math&gt;.


:[[9.19]]. A Babbage square is a grid of words that reads the same across as it does down. Given a &lt;math&gt;k&lt;/math&gt;-letter word &lt;math&gt;w&lt;/math&gt; and a dictionary of &lt;math&gt;n&lt;/math&gt; words, find all Babbage squares starting with that word. For example, two squares for the word hair are:
&lt;center&gt;&lt;math&gt;\begin{vmatrix}
h &amp; a &amp; i &amp; r\\
a &amp; i &amp; d &amp; e\\
i &amp; d &amp; l &amp; e\\
r &amp; e &amp; e &amp; f
\end{vmatrix}\begin{vmatrix}
h &amp; a &amp; i &amp; r\\
a &amp; l &amp; t &amp; o\\
i &amp; t &amp; e &amp; m\\
r &amp; o &amp; m &amp; b
\end{vmatrix}
&lt;/math&gt;&lt;/center&gt;
[[9.19|Solution]]


:9.20. Show that you can solve any given Sudoku puzzle by finding the minimum vertex coloring of a specific, appropriately constructed 9 × 9 + 9 vertex graph.

===Combinatorial Optimization=== 
For problems 9-21 to 9-27, implement a combinatorial search program to solve it for small instances. How well does your program perform in practice?

:[[9.21]]. Design and implement an algorithm for solving the bandwidth minimization problem discussed in Section 16.2 (page 470).
[[9.21|Solution]]


:9.22. Design and implement an algorithm for solving the maximum satisfiability problem discussed in Section 17.10 (page 537).


:[[9.23]]. Design and implement an algorithm for solving the maximum clique problem discussed in Section 19.1 (page 586).
[[9.23|Solution]]


:9.24. Design and implement an algorithm for solving the minimum vertex coloring problem discussed in Section 19.7 (page 604).


:[[9.25]]. Design and implement an algorithm for solving the minimum edge coloring problem discussed in Section 19.8 (page 608).
[[9.25|Solution]]


:9.26. Design and implement an algorithm for solving the minimum feedback vertex set problem discussed in Section 19.11 (page 618).


:[[9.27]]. Design and implement an algorithm for solving the set cover problem discussed in Section 21.1 (page 678).
[[9.27|Solution]]

===Interview Problems===

:9.28. Write a function to find all permutations of the letters in a given string.


:[[9.29]]. Implement an efficient algorithm for listing all &lt;math&gt;k&lt;/math&gt;-element subsets of &lt;math&gt;n&lt;/math&gt; items.
[[9.29|Solution]]


:9.30. An anagram is a rearrangement of the letters in a given string into a sequence of dictionary words, like ''Steven Skiena'' into ''Vainest Knees''. Propose an algorithm to construct all the anagrams of a given string.


:[[9.31]]. Telephone keypads have letters on each numerical key. Write a program that generates all possible words resulting from translating a given digit sequence (e.g. 145345) into letters.
[[9.31|Solution]]


:9.32. You start with an empty room and a group of &lt;math&gt;n&lt;/math&gt; people waiting outside. At each step, you may either admit one person into the room, or let one out. Can you arrange a sequence of &lt;math&gt;2n&lt;/math&gt; steps, so that every possible combination of people is achieved exactly once?


:[[9.33]]. Use a random number generator (rng04) that generates numbers from {0, 1, 2, 3, 4} with equal probability to write a random number generator that generates numbers from 0 to 7 (rng07) with equal probability. What is the expected number of calls to rng04 per call of rng07?
[[9.33|Solution]]


Back to [[Chapter List]]</text>
      <sha1>cdswxo6wxx9lfrfkruyhecz3br8bpch</sha1>
    </revision>
    <revision>
      <id>408</id>
      <parentid>230</parentid>
      <timestamp>2020-09-21T14:00:59Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Combinatorial Optimization */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="10029">=Combinatorial Search=

===Permutations===

:[[9.1]]. A ''derangement'' is a permutation &lt;math&gt;p&lt;/math&gt; of &lt;math&gt;{1, . . . , n}&lt;/math&gt; such that no item is in its proper position, that is, &lt;math&gt;p_i 6= i&lt;/math&gt; for all &lt;math&gt;1 \leq i \leq n&lt;/math&gt;. Write an efficient backtracking program with pruning that constructs all the derangements of &lt;math&gt;n&lt;/math&gt; items.
[[9.1|Soluiton]]


:9.2. ''Multisets'' are allowed to have repeated elements. A multiset of n items may thus have fewer than &lt;math&gt;n!&lt;/math&gt; distinct permutations. For example, {1, 1, 2, 2} has only six distinct permutations: [1, 1, 2, 2], [1, 2, 1, 2], [1, 2, 2, 1], [2, 1, 1, 2], [2, 1, 2, 1], and [2, 2, 1, 1]. Design and implement an efficient algorithm for constructing all permutations of a multiset.


:[[9.3]]. For a given a positive integer &lt;math&gt;n&lt;/math&gt;, find all permutations of the &lt;math&gt;2n&lt;/math&gt; elements of the multiset &lt;math&gt;S = {1, 1, 2, 2, 3, 3, . . . , n, n}&lt;/math&gt; such that for each integer from 1 to &lt;math&gt;n&lt;/math&gt; the number of intervening elements between its two appearances is equal to value of the element. For example, when &lt;math&gt;n = 3&lt;/math&gt; the two possible solutions are [3, 1, 2, 1, 3, 2] and [2, 3, 1, 2, 1, 3].
[[9.3|Solution]]


:9.4. Design and implement an algorithm for testing whether two graphs are isomorphic. The graph isomorphism problem is discussed in Section 19.9 (page 610). With proper pruning, graphs on hundreds of vertices can be tested in a reasonable time.


:[[9.5]]. The set &lt;math&gt;{1, 2, 3, ..., n}&lt;/math&gt; contains a total of &lt;math&gt;n!&lt;/math&gt; distinct permutations. By listing and labeling all of the permutations in ascending lexicographic order, we get the following sequence for &lt;math&gt;n = 3&lt;/math&gt;: 
&lt;center&gt;&lt;math&gt;[123, 132, 213, 231, 312, 321]&lt;/math&gt;&lt;/center&gt;
:Give an efficient algorithm that returns the &lt;math&gt;k&lt;/math&gt;th of &lt;math&gt;n!&lt;/math&gt; permutations in this see quence, for inputs &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. For efficiency it should not construct the first &lt;math&gt;k - 1&lt;/math&gt; permutations in the process.
[[9.5|Solution]]

===Backtracking===

:9.6. Generate all structurally distinct binary search trees that store values &lt;math&gt;1 . . . n&lt;/math&gt;, for a given value of &lt;math&gt;n&lt;/math&gt;.


:[[9.7]]. Implement an algorithm to print all valid (meaning properly opened and closed) sequences of n pairs of parentheses.
[[9.7|Solution]]


:9.8. Generate all possible topological orderings of a given DAG.


:[[9.9]]. Given a specified total t and a multiset &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find all distinct subsets from &lt;math&gt;S&lt;/math&gt; whose elements add up to &lt;math&gt;t&lt;/math&gt;. For example, if &lt;math&gt;t = 4&lt;/math&gt; and &lt;math&gt;S = {4, 3, 2, 2, 1, 1}&lt;/math&gt;, then there are four different sums that equal &lt;math&gt;t: 4, 3 + 1, 2 + 2&lt;/math&gt;, and &lt;math&gt;2 + 1 + 1&lt;/math&gt;. A number can be used within a sum up to the number of times it appears in &lt;math&gt;S&lt;/math&gt;, and a single number counts as a sum.
[[9.9|Solution]]


:9.10. Given a specified total &lt;math&gt;t&lt;/math&gt; and a multiset &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find all distinct subsets from &lt;math&gt;S&lt;/math&gt; whose elements add up to &lt;math&gt;t&lt;/math&gt;. For example, if &lt;math&gt;t = 4&lt;/math&gt; and &lt;math&gt;S = {4, 3, 2, 2, 1, 1}&lt;/math&gt;, then there are four different sums that equal &lt;math&gt;t: 4, 3 + 1, 2 + 2&lt;/math&gt;, and &lt;math&gt;2 + 1 + 1&lt;/math&gt;. A number can be used within a sum up to the number of times it appears in &lt;math&gt;S&lt;/math&gt;, and a single number counts as a sum.


:[[9.11]]. A team assignment of &lt;math&gt;n = 2k&lt;/math&gt; players is a partitioning of them into two teams with exactly &lt;math&gt;k&lt;/math&gt; people per team. For example, if the players are named &lt;math&gt;{A, B, C, D}&lt;/math&gt;, there are three distinct ways to partition them into two equal teams: &lt;math&gt;{{A, B}, {C, D}}, {{A, C}, {B, D}}, and {{A, D}, {B, C}}&lt;/math&gt;. 
:(a) List the 10 possible team assignments for &lt;math&gt;n = 6&lt;/math&gt; players.
:(b) Give an efficient back-tracking algorithm to construct all possible team assignments. Be sure to avoid repeating any solution.
[[9.11|Solution]]


:9.12. Given an alphabet &lt;math&gt;\Sigma&lt;/math&gt;, a set of forbidden strings &lt;math&gt;S&lt;/math&gt;, and a target length &lt;math&gt;n&lt;/math&gt;, give an algorithm to construct a string of length &lt;math&gt;n&lt;/math&gt; on &lt;math&gt;\Sigma&lt;/math&gt; without any element of &lt;math&gt;S&lt;/math&gt; as a substring. For &lt;math&gt;\Sigma = {0, 1}, S = {01, 10}&lt;math&gt;, and &lt;math&gt;n = 4&lt;/math&gt;, the two possible solutions are 0000 and 1111. For &lt;math&gt;S = {0, 11}&lt;/math&gt; and &lt;math&gt;n = 4&lt;/math&gt;, no such string exists.


:[[9.13]]. In the &lt;math&gt;k&lt;/math&gt;-partition problem, we need to partition a multiset of positive integers into &lt;math&gt;k&lt;/math&gt; disjoint subsets that have equal sum. Design and implement an algorithm for solving the &lt;math&gt;k&lt;/math&gt;-partition problem.
[[9.13|Solution]]


:9.14. You are given a weighted directed graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges. The mean weight of a cycle is the sum of its edge weights divided by the number of its edges. Find a cycle in &lt;math&gt;G&lt;/math&gt; of minimum mean weight.


:[[9.15]]. In the turnpike reconstruction problem, you are given a multiset &lt;math&gt;D&lt;/math&gt; of &lt;math&gt;n(n - 1)/2&lt;/math&gt; distances. The problem is to place &lt;math&gt;n&lt;/math&gt; points on the line such that their pairwise distances are &lt;math&gt;D&lt;/math&gt;. For example, the distances &lt;math&gt;D = {1, 2, 3, 4, 5, 6}&lt;/math&gt; can be obtained by placing the second point 1 unit from the first, the third point 3 from the second, and the fourth point 2 from the third. Design and implement an efficient algorithm to find all solutions to the turnpike reconstruction problem. Exploit additive constraints when possible to accelerate the search. With proper pruning, problems with hundreds of points can be solved in reasonable time.
[[9.15|Solution]]

===Games and Puzzles===

:9.16. Anagrams are rearrangements of the letters of a word or phrase into a different word or phrase. Sometimes the results are quite striking. For example, “MANY VOTED BUSH RETIRED” is an anagram of “TUESDAY NOVEMBER THIRD,” which correctly predicted the result of the 1992 US presidential election. Design and implement an algorithm for finding anagrams using combinatorial search and a dictionary.


:[[9.17]]. Construct all sequences of moves that a knight on an &lt;math&gt;n * n&lt;/math&gt; chessboard can make where the knight visits every square only once.
[[9.17|Solution]]


:9.18. A Boggle board is an &lt;math&gt;n * m&lt;/math&gt; grid of characters. For a given board, we seek to find all possible words that can be formed by a sequence of adjacent characters on the board, without repetition. For example, the board:
&lt;center&gt;&lt;math&gt;\begin{matrix}
e &amp; t &amp; h &amp; t\\
n &amp; d &amp; t &amp; i\\
a &amp; i &amp; h &amp; n\\
r &amp; h &amp; u &amp; b
\end{matrix}&lt;/math&gt;&lt;/center&gt;
:contains words like tide, dent, raid, and hide. Design an algorithm to construct the most words for a given board &lt;math&gt;B&lt;/math&gt; consistent with a dictionary &lt;math&gt;D&lt;/math&gt;.


:[[9.19]]. A Babbage square is a grid of words that reads the same across as it does down. Given a &lt;math&gt;k&lt;/math&gt;-letter word &lt;math&gt;w&lt;/math&gt; and a dictionary of &lt;math&gt;n&lt;/math&gt; words, find all Babbage squares starting with that word. For example, two squares for the word hair are:
&lt;center&gt;&lt;math&gt;\begin{vmatrix}
h &amp; a &amp; i &amp; r\\
a &amp; i &amp; d &amp; e\\
i &amp; d &amp; l &amp; e\\
r &amp; e &amp; e &amp; f
\end{vmatrix}\begin{vmatrix}
h &amp; a &amp; i &amp; r\\
a &amp; l &amp; t &amp; o\\
i &amp; t &amp; e &amp; m\\
r &amp; o &amp; m &amp; b
\end{vmatrix}
&lt;/math&gt;&lt;/center&gt;
[[9.19|Solution]]


:9.20. Show that you can solve any given Sudoku puzzle by finding the minimum vertex coloring of a specific, appropriately constructed 9 × 9 + 9 vertex graph.

===Combinatorial Optimization=== 
For problems 9-21 to 9-27, implement a combinatorial search program to solve it for small instances. How well does your program perform in practice?


:[[9.21]]. Design and implement an algorithm for solving the bandwidth minimization problem discussed in Section 16.2 (page 470).
[[9.21|Solution]]


:9.22. Design and implement an algorithm for solving the maximum satisfiability problem discussed in Section 17.10 (page 537).


:[[9.23]]. Design and implement an algorithm for solving the maximum clique problem discussed in Section 19.1 (page 586).
[[9.23|Solution]]


:9.24. Design and implement an algorithm for solving the minimum vertex coloring problem discussed in Section 19.7 (page 604).


:[[9.25]]. Design and implement an algorithm for solving the minimum edge coloring problem discussed in Section 19.8 (page 608).
[[9.25|Solution]]


:9.26. Design and implement an algorithm for solving the minimum feedback vertex set problem discussed in Section 19.11 (page 618).


:[[9.27]]. Design and implement an algorithm for solving the set cover problem discussed in Section 21.1 (page 678).
[[9.27|Solution]]

===Interview Problems===

:9.28. Write a function to find all permutations of the letters in a given string.


:[[9.29]]. Implement an efficient algorithm for listing all &lt;math&gt;k&lt;/math&gt;-element subsets of &lt;math&gt;n&lt;/math&gt; items.
[[9.29|Solution]]


:9.30. An anagram is a rearrangement of the letters in a given string into a sequence of dictionary words, like ''Steven Skiena'' into ''Vainest Knees''. Propose an algorithm to construct all the anagrams of a given string.


:[[9.31]]. Telephone keypads have letters on each numerical key. Write a program that generates all possible words resulting from translating a given digit sequence (e.g. 145345) into letters.
[[9.31|Solution]]


:9.32. You start with an empty room and a group of &lt;math&gt;n&lt;/math&gt; people waiting outside. At each step, you may either admit one person into the room, or let one out. Can you arrange a sequence of &lt;math&gt;2n&lt;/math&gt; steps, so that every possible combination of people is achieved exactly once?


:[[9.33]]. Use a random number generator (rng04) that generates numbers from {0, 1, 2, 3, 4} with equal probability to write a random number generator that generates numbers from 0 to 7 (rng07) with equal probability. What is the expected number of calls to rng04 per call of rng07?
[[9.33|Solution]]


Back to [[Chapter List]]</text>
      <sha1>8us92kzsccb6uhh3zr9634wcatm2o2a</sha1>
    </revision>
    <revision>
      <id>455</id>
      <parentid>408</parentid>
      <timestamp>2020-10-01T18:10:14Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <minor/>
      <comment>Protected "[[Chapter 9]]" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="10029">=Combinatorial Search=

===Permutations===

:[[9.1]]. A ''derangement'' is a permutation &lt;math&gt;p&lt;/math&gt; of &lt;math&gt;{1, . . . , n}&lt;/math&gt; such that no item is in its proper position, that is, &lt;math&gt;p_i 6= i&lt;/math&gt; for all &lt;math&gt;1 \leq i \leq n&lt;/math&gt;. Write an efficient backtracking program with pruning that constructs all the derangements of &lt;math&gt;n&lt;/math&gt; items.
[[9.1|Soluiton]]


:9.2. ''Multisets'' are allowed to have repeated elements. A multiset of n items may thus have fewer than &lt;math&gt;n!&lt;/math&gt; distinct permutations. For example, {1, 1, 2, 2} has only six distinct permutations: [1, 1, 2, 2], [1, 2, 1, 2], [1, 2, 2, 1], [2, 1, 1, 2], [2, 1, 2, 1], and [2, 2, 1, 1]. Design and implement an efficient algorithm for constructing all permutations of a multiset.


:[[9.3]]. For a given a positive integer &lt;math&gt;n&lt;/math&gt;, find all permutations of the &lt;math&gt;2n&lt;/math&gt; elements of the multiset &lt;math&gt;S = {1, 1, 2, 2, 3, 3, . . . , n, n}&lt;/math&gt; such that for each integer from 1 to &lt;math&gt;n&lt;/math&gt; the number of intervening elements between its two appearances is equal to value of the element. For example, when &lt;math&gt;n = 3&lt;/math&gt; the two possible solutions are [3, 1, 2, 1, 3, 2] and [2, 3, 1, 2, 1, 3].
[[9.3|Solution]]


:9.4. Design and implement an algorithm for testing whether two graphs are isomorphic. The graph isomorphism problem is discussed in Section 19.9 (page 610). With proper pruning, graphs on hundreds of vertices can be tested in a reasonable time.


:[[9.5]]. The set &lt;math&gt;{1, 2, 3, ..., n}&lt;/math&gt; contains a total of &lt;math&gt;n!&lt;/math&gt; distinct permutations. By listing and labeling all of the permutations in ascending lexicographic order, we get the following sequence for &lt;math&gt;n = 3&lt;/math&gt;: 
&lt;center&gt;&lt;math&gt;[123, 132, 213, 231, 312, 321]&lt;/math&gt;&lt;/center&gt;
:Give an efficient algorithm that returns the &lt;math&gt;k&lt;/math&gt;th of &lt;math&gt;n!&lt;/math&gt; permutations in this see quence, for inputs &lt;math&gt;n&lt;/math&gt; and &lt;math&gt;k&lt;/math&gt;. For efficiency it should not construct the first &lt;math&gt;k - 1&lt;/math&gt; permutations in the process.
[[9.5|Solution]]

===Backtracking===

:9.6. Generate all structurally distinct binary search trees that store values &lt;math&gt;1 . . . n&lt;/math&gt;, for a given value of &lt;math&gt;n&lt;/math&gt;.


:[[9.7]]. Implement an algorithm to print all valid (meaning properly opened and closed) sequences of n pairs of parentheses.
[[9.7|Solution]]


:9.8. Generate all possible topological orderings of a given DAG.


:[[9.9]]. Given a specified total t and a multiset &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find all distinct subsets from &lt;math&gt;S&lt;/math&gt; whose elements add up to &lt;math&gt;t&lt;/math&gt;. For example, if &lt;math&gt;t = 4&lt;/math&gt; and &lt;math&gt;S = {4, 3, 2, 2, 1, 1}&lt;/math&gt;, then there are four different sums that equal &lt;math&gt;t: 4, 3 + 1, 2 + 2&lt;/math&gt;, and &lt;math&gt;2 + 1 + 1&lt;/math&gt;. A number can be used within a sum up to the number of times it appears in &lt;math&gt;S&lt;/math&gt;, and a single number counts as a sum.
[[9.9|Solution]]


:9.10. Given a specified total &lt;math&gt;t&lt;/math&gt; and a multiset &lt;math&gt;S&lt;/math&gt; of &lt;math&gt;n&lt;/math&gt; integers, find all distinct subsets from &lt;math&gt;S&lt;/math&gt; whose elements add up to &lt;math&gt;t&lt;/math&gt;. For example, if &lt;math&gt;t = 4&lt;/math&gt; and &lt;math&gt;S = {4, 3, 2, 2, 1, 1}&lt;/math&gt;, then there are four different sums that equal &lt;math&gt;t: 4, 3 + 1, 2 + 2&lt;/math&gt;, and &lt;math&gt;2 + 1 + 1&lt;/math&gt;. A number can be used within a sum up to the number of times it appears in &lt;math&gt;S&lt;/math&gt;, and a single number counts as a sum.


:[[9.11]]. A team assignment of &lt;math&gt;n = 2k&lt;/math&gt; players is a partitioning of them into two teams with exactly &lt;math&gt;k&lt;/math&gt; people per team. For example, if the players are named &lt;math&gt;{A, B, C, D}&lt;/math&gt;, there are three distinct ways to partition them into two equal teams: &lt;math&gt;{{A, B}, {C, D}}, {{A, C}, {B, D}}, and {{A, D}, {B, C}}&lt;/math&gt;. 
:(a) List the 10 possible team assignments for &lt;math&gt;n = 6&lt;/math&gt; players.
:(b) Give an efficient back-tracking algorithm to construct all possible team assignments. Be sure to avoid repeating any solution.
[[9.11|Solution]]


:9.12. Given an alphabet &lt;math&gt;\Sigma&lt;/math&gt;, a set of forbidden strings &lt;math&gt;S&lt;/math&gt;, and a target length &lt;math&gt;n&lt;/math&gt;, give an algorithm to construct a string of length &lt;math&gt;n&lt;/math&gt; on &lt;math&gt;\Sigma&lt;/math&gt; without any element of &lt;math&gt;S&lt;/math&gt; as a substring. For &lt;math&gt;\Sigma = {0, 1}, S = {01, 10}&lt;math&gt;, and &lt;math&gt;n = 4&lt;/math&gt;, the two possible solutions are 0000 and 1111. For &lt;math&gt;S = {0, 11}&lt;/math&gt; and &lt;math&gt;n = 4&lt;/math&gt;, no such string exists.


:[[9.13]]. In the &lt;math&gt;k&lt;/math&gt;-partition problem, we need to partition a multiset of positive integers into &lt;math&gt;k&lt;/math&gt; disjoint subsets that have equal sum. Design and implement an algorithm for solving the &lt;math&gt;k&lt;/math&gt;-partition problem.
[[9.13|Solution]]


:9.14. You are given a weighted directed graph &lt;math&gt;G&lt;/math&gt; with &lt;math&gt;n&lt;/math&gt; vertices and &lt;math&gt;m&lt;/math&gt; edges. The mean weight of a cycle is the sum of its edge weights divided by the number of its edges. Find a cycle in &lt;math&gt;G&lt;/math&gt; of minimum mean weight.


:[[9.15]]. In the turnpike reconstruction problem, you are given a multiset &lt;math&gt;D&lt;/math&gt; of &lt;math&gt;n(n - 1)/2&lt;/math&gt; distances. The problem is to place &lt;math&gt;n&lt;/math&gt; points on the line such that their pairwise distances are &lt;math&gt;D&lt;/math&gt;. For example, the distances &lt;math&gt;D = {1, 2, 3, 4, 5, 6}&lt;/math&gt; can be obtained by placing the second point 1 unit from the first, the third point 3 from the second, and the fourth point 2 from the third. Design and implement an efficient algorithm to find all solutions to the turnpike reconstruction problem. Exploit additive constraints when possible to accelerate the search. With proper pruning, problems with hundreds of points can be solved in reasonable time.
[[9.15|Solution]]

===Games and Puzzles===

:9.16. Anagrams are rearrangements of the letters of a word or phrase into a different word or phrase. Sometimes the results are quite striking. For example, “MANY VOTED BUSH RETIRED” is an anagram of “TUESDAY NOVEMBER THIRD,” which correctly predicted the result of the 1992 US presidential election. Design and implement an algorithm for finding anagrams using combinatorial search and a dictionary.


:[[9.17]]. Construct all sequences of moves that a knight on an &lt;math&gt;n * n&lt;/math&gt; chessboard can make where the knight visits every square only once.
[[9.17|Solution]]


:9.18. A Boggle board is an &lt;math&gt;n * m&lt;/math&gt; grid of characters. For a given board, we seek to find all possible words that can be formed by a sequence of adjacent characters on the board, without repetition. For example, the board:
&lt;center&gt;&lt;math&gt;\begin{matrix}
e &amp; t &amp; h &amp; t\\
n &amp; d &amp; t &amp; i\\
a &amp; i &amp; h &amp; n\\
r &amp; h &amp; u &amp; b
\end{matrix}&lt;/math&gt;&lt;/center&gt;
:contains words like tide, dent, raid, and hide. Design an algorithm to construct the most words for a given board &lt;math&gt;B&lt;/math&gt; consistent with a dictionary &lt;math&gt;D&lt;/math&gt;.


:[[9.19]]. A Babbage square is a grid of words that reads the same across as it does down. Given a &lt;math&gt;k&lt;/math&gt;-letter word &lt;math&gt;w&lt;/math&gt; and a dictionary of &lt;math&gt;n&lt;/math&gt; words, find all Babbage squares starting with that word. For example, two squares for the word hair are:
&lt;center&gt;&lt;math&gt;\begin{vmatrix}
h &amp; a &amp; i &amp; r\\
a &amp; i &amp; d &amp; e\\
i &amp; d &amp; l &amp; e\\
r &amp; e &amp; e &amp; f
\end{vmatrix}\begin{vmatrix}
h &amp; a &amp; i &amp; r\\
a &amp; l &amp; t &amp; o\\
i &amp; t &amp; e &amp; m\\
r &amp; o &amp; m &amp; b
\end{vmatrix}
&lt;/math&gt;&lt;/center&gt;
[[9.19|Solution]]


:9.20. Show that you can solve any given Sudoku puzzle by finding the minimum vertex coloring of a specific, appropriately constructed 9 × 9 + 9 vertex graph.

===Combinatorial Optimization=== 
For problems 9-21 to 9-27, implement a combinatorial search program to solve it for small instances. How well does your program perform in practice?


:[[9.21]]. Design and implement an algorithm for solving the bandwidth minimization problem discussed in Section 16.2 (page 470).
[[9.21|Solution]]


:9.22. Design and implement an algorithm for solving the maximum satisfiability problem discussed in Section 17.10 (page 537).


:[[9.23]]. Design and implement an algorithm for solving the maximum clique problem discussed in Section 19.1 (page 586).
[[9.23|Solution]]


:9.24. Design and implement an algorithm for solving the minimum vertex coloring problem discussed in Section 19.7 (page 604).


:[[9.25]]. Design and implement an algorithm for solving the minimum edge coloring problem discussed in Section 19.8 (page 608).
[[9.25|Solution]]


:9.26. Design and implement an algorithm for solving the minimum feedback vertex set problem discussed in Section 19.11 (page 618).


:[[9.27]]. Design and implement an algorithm for solving the set cover problem discussed in Section 21.1 (page 678).
[[9.27|Solution]]

===Interview Problems===

:9.28. Write a function to find all permutations of the letters in a given string.


:[[9.29]]. Implement an efficient algorithm for listing all &lt;math&gt;k&lt;/math&gt;-element subsets of &lt;math&gt;n&lt;/math&gt; items.
[[9.29|Solution]]


:9.30. An anagram is a rearrangement of the letters in a given string into a sequence of dictionary words, like ''Steven Skiena'' into ''Vainest Knees''. Propose an algorithm to construct all the anagrams of a given string.


:[[9.31]]. Telephone keypads have letters on each numerical key. Write a program that generates all possible words resulting from translating a given digit sequence (e.g. 145345) into letters.
[[9.31|Solution]]


:9.32. You start with an empty room and a group of &lt;math&gt;n&lt;/math&gt; people waiting outside. At each step, you may either admit one person into the room, or let one out. Can you arrange a sequence of &lt;math&gt;2n&lt;/math&gt; steps, so that every possible combination of people is achieved exactly once?


:[[9.33]]. Use a random number generator (rng04) that generates numbers from {0, 1, 2, 3, 4} with equal probability to write a random number generator that generates numbers from 0 to 7 (rng07) with equal probability. What is the expected number of calls to rng04 per call of rng07?
[[9.33|Solution]]


Back to [[Chapter List]]</text>
      <sha1>8us92kzsccb6uhh3zr9634wcatm2o2a</sha1>
    </revision>
  </page>
  <page>
    <title>Chapter List</title>
    <ns>0</ns>
    <id>2</id>
    <revision>
      <id>3</id>
      <timestamp>2020-08-23T18:38:14Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "Chapters  *[[Chapter 1]]  *[[Chapter 2]]  *[[Chapter 3]]  *[[Chapter 4]]  *[[Chapter 5]]  *[[Chapter 6]]  *[[Chapter 7]]  *[[Chapter 8]]  *[[Chapter 9]]  *[[Chapter 10]]  *C..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="203">Chapters

*[[Chapter 1]]

*[[Chapter 2]]

*[[Chapter 3]]

*[[Chapter 4]]

*[[Chapter 5]]

*[[Chapter 6]]

*[[Chapter 7]]

*[[Chapter 8]]

*[[Chapter 9]]

*[[Chapter 10]]

*[[Chapter 11]]

*[[Chapter 12]]</text>
      <sha1>6ebo872f5c66jcu3qsjew5k6qrka5ov</sha1>
    </revision>
    <revision>
      <id>9</id>
      <parentid>3</parentid>
      <timestamp>2020-08-23T19:30:09Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <minor/>
      <comment>Algowikiadmin moved page [[Problem Solutions]] to [[Chapter List]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="203">Chapters

*[[Chapter 1]]

*[[Chapter 2]]

*[[Chapter 3]]

*[[Chapter 4]]

*[[Chapter 5]]

*[[Chapter 6]]

*[[Chapter 7]]

*[[Chapter 8]]

*[[Chapter 9]]

*[[Chapter 10]]

*[[Chapter 11]]

*[[Chapter 12]]</text>
      <sha1>6ebo872f5c66jcu3qsjew5k6qrka5ov</sha1>
    </revision>
    <revision>
      <id>439</id>
      <parentid>9</parentid>
      <timestamp>2020-09-28T17:39:25Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="441">Chapters

#[[Chapter 1|Introduction to Algorithms]]
#[[Chapter 2|Algorithm Analysis]]
#[[Chapter 3|Data Structures]]
#[[Chapter 4|Sorting]]
#[[Chapter 5|Divide and Conquer]]
#[[Chapter 6|Hashing and Randomized Algorithms]]
#[[Chapter 7|Graph Traversal]]
#[[Chapter 8|Weighted Graph Algorithms]]
#[[Chapter 9|Combinatorial Search]]
#[[Chapter 10|Dynamic Programming]]
#[[Chapter 11|NP-Completeness]]
#[[Chapter 12|Dealing with Hard Problems]]</text>
      <sha1>p3r919nekq1mho0s9lsp3m0odqsgkdy</sha1>
    </revision>
    <revision>
      <id>447</id>
      <parentid>439</parentid>
      <timestamp>2020-10-01T18:06:08Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <minor/>
      <comment>Protected "[[Chapter List]]" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="441">Chapters

#[[Chapter 1|Introduction to Algorithms]]
#[[Chapter 2|Algorithm Analysis]]
#[[Chapter 3|Data Structures]]
#[[Chapter 4|Sorting]]
#[[Chapter 5|Divide and Conquer]]
#[[Chapter 6|Hashing and Randomized Algorithms]]
#[[Chapter 7|Graph Traversal]]
#[[Chapter 8|Weighted Graph Algorithms]]
#[[Chapter 9|Combinatorial Search]]
#[[Chapter 10|Dynamic Programming]]
#[[Chapter 11|NP-Completeness]]
#[[Chapter 12|Dealing with Hard Problems]]</text>
      <sha1>p3r919nekq1mho0s9lsp3m0odqsgkdy</sha1>
    </revision>
  </page>
  <page>
    <title>Main Page</title>
    <ns>0</ns>
    <id>1</id>
    <redirect title="Solution Wiki, The Algorithm Design Manual, 3rd Edition" />
    <revision>
      <id>1</id>
      <timestamp>2020-08-18T01:36:51Z</timestamp>
      <contributor>
        <username>MediaWiki default</username>
        <id>2</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="735">&lt;strong&gt;MediaWiki has been installed.&lt;/strong&gt;

Consult the [https://www.mediawiki.org/wiki/Special:MyLanguage/Help:Contents User's Guide] for information on using the wiki software.

== Getting started ==
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Configuration_settings Configuration settings list]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:FAQ MediaWiki FAQ]
* [https://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation#Translation_resources Localise MediaWiki for your language]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Combating_spam Learn how to combat spam on your wiki]</text>
      <sha1>a5wehuldd0go2uniagwvx66n6c80irq</sha1>
    </revision>
    <revision>
      <id>2</id>
      <parentid>1</parentid>
      <timestamp>2020-08-23T18:36:40Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="585">[[About]]

[[Problem Solutions]]

== Getting started ==
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Configuration_settings Configuration settings list]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:FAQ MediaWiki FAQ]
* [https://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation#Translation_resources Localise MediaWiki for your language]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Combating_spam Learn how to combat spam on your wiki]</text>
      <sha1>12pzvj9jb9lo0koxyuktydzmpr3stlg</sha1>
    </revision>
    <revision>
      <id>11</id>
      <parentid>2</parentid>
      <timestamp>2020-08-23T19:30:36Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="580">[[About]]

[[Chapter List]]

== Getting started ==
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Configuration_settings Configuration settings list]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:FAQ MediaWiki FAQ]
* [https://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation#Translation_resources Localise MediaWiki for your language]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Combating_spam Learn how to combat spam on your wiki]</text>
      <sha1>qdgmbmqfjzidl0e55n8tbbkjbgxigoz</sha1>
    </revision>
    <revision>
      <id>434</id>
      <parentid>11</parentid>
      <timestamp>2020-09-28T17:26:46Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1293">The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with Steven Skiena's The Algorithm Design Manual. Students and other readers are encouraged to contribute hints and answers to all odd numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.

[[Chapter List]]

== Getting started ==
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Configuration_settings Configuration settings list]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:FAQ MediaWiki FAQ]
* [https://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation#Translation_resources Localise MediaWiki for your language]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Combating_spam Learn how to combat spam on your wiki]</text>
      <sha1>t5v2xu80q9t5rao7dzvfbyrqubxyg2n</sha1>
    </revision>
    <revision>
      <id>435</id>
      <parentid>434</parentid>
      <timestamp>2020-09-28T17:27:37Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1320">The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with Steven Skiena's The Algorithm Design Manual. Students and other readers are encouraged to contribute hints and answers to all odd numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.

[[Chapter List]]

== Getting started ==
; Editing
* [http://meta.wikimedia.org/wiki/Help:Formula MediaWiki Help:Formula]
* [http://meta.wikimedia.org/wiki/Help:Wikitext_examples Help:Wikitext Examples]

; Configuration
* [http://www.mediawiki.org/wiki/Manual:Configuration_settings Configuration settings list]

; Mediawiki General
* [http://www.mediawiki.org/wiki/Manual:FAQ MediaWiki FAQ]
* [http://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

; Questions
* [http://www.cs.sunysb.edu/~skiena/ Steven Skiena] (for additional hints and algorithm magic)</text>
      <sha1>koxst2wjy6kkzfmzlgfmh3m7p9m4c4z</sha1>
    </revision>
    <revision>
      <id>436</id>
      <parentid>435</parentid>
      <timestamp>2020-09-28T17:29:58Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1415">The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with the third edition of Steven Skiena's ''The Algorithm Design Manual''. Students and other readers are encouraged to contribute hints and answers to all odd-numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.


[[Chapter List]]

== Getting started ==
; Editing
* [http://meta.wikimedia.org/wiki/Help:Formula MediaWiki Help:Formula]
* [http://meta.wikimedia.org/wiki/Help:Wikitext_examples Help:Wikitext Examples]

; Configuration
* [http://www.mediawiki.org/wiki/Manual:Configuration_settings Configuration settings list]

; Mediawiki General
* [http://www.mediawiki.org/wiki/Manual:FAQ MediaWiki FAQ]
* [http://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

; Questions
*[[User: Algowikiadmin| The Admin]] (editing fixes for the problems)
* [http://www.cs.sunysb.edu/~skiena/ Steven Skiena] (for additional hints and algorithm magic)</text>
      <sha1>qzczuo86hgihjln2mcal8kd1khnjqiz</sha1>
    </revision>
    <revision>
      <id>440</id>
      <parentid>436</parentid>
      <timestamp>2020-09-28T17:54:50Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1480">The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with the third edition of Steven Skiena's ''The Algorithm Design Manual''. Students and other readers are encouraged to contribute hints and answers to all odd-numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.

The chapters and their corresponding exercises can be found [[Chapter List|here]].

== Getting started ==
; Editing
* [http://meta.wikimedia.org/wiki/Help:Formula MediaWiki Help:Formula]
* [http://meta.wikimedia.org/wiki/Help:Wikitext_examples Help:Wikitext Examples]

; Configuration
* [http://www.mediawiki.org/wiki/Manual:Configuration_settings Configuration settings list]

; Mediawiki General
* [http://www.mediawiki.org/wiki/Manual:FAQ MediaWiki FAQ]
* [http://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

; Questions
*[[User: Algowikiadmin| The Admin]] (editing fixes for the problems)
* [http://www.cs.sunysb.edu/~skiena/ Steven Skiena] (for additional hints and algorithm magic)</text>
      <sha1>8heer3ilp0xmzwrueuq0mndvg83l8u5</sha1>
    </revision>
    <revision>
      <id>441</id>
      <parentid>440</parentid>
      <timestamp>2020-09-28T17:55:00Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1481">The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with the third edition of Steven Skiena's ''The Algorithm Design Manual''. Students and other readers are encouraged to contribute hints and answers to all odd-numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.


The chapters and their corresponding exercises can be found [[Chapter List|here]].

== Getting started ==
; Editing
* [http://meta.wikimedia.org/wiki/Help:Formula MediaWiki Help:Formula]
* [http://meta.wikimedia.org/wiki/Help:Wikitext_examples Help:Wikitext Examples]

; Configuration
* [http://www.mediawiki.org/wiki/Manual:Configuration_settings Configuration settings list]

; Mediawiki General
* [http://www.mediawiki.org/wiki/Manual:FAQ MediaWiki FAQ]
* [http://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

; Questions
*[[User: Algowikiadmin| The Admin]] (editing fixes for the problems)
* [http://www.cs.sunysb.edu/~skiena/ Steven Skiena] (for additional hints and algorithm magic)</text>
      <sha1>ompebjpnq5yirrt1d2rn60ns8jnhsrq</sha1>
    </revision>
    <revision>
      <id>442</id>
      <parentid>441</parentid>
      <timestamp>2020-10-01T18:00:51Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1845">The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with the third edition of Steven Skiena's ''The Algorithm Design Manual''. Students and other readers are encouraged to contribute hints and answers to all odd-numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.


==Chapters==

#[[Chapter 1|Introduction to Algorithms]]
#[[Chapter 2|Algorithm Analysis]]
#[[Chapter 3|Data Structures]]
#[[Chapter 4|Sorting]]
#[[Chapter 5|Divide and Conquer]]
#[[Chapter 6|Hashing and Randomized Algorithms]]
#[[Chapter 7|Graph Traversal]]
#[[Chapter 8|Weighted Graph Algorithms]]
#[[Chapter 9|Combinatorial Search]]
#[[Chapter 10|Dynamic Programming]]
#[[Chapter 11|NP-Completeness]]
#[[Chapter 12|Dealing with Hard Problems]]


== Getting started ==
; Editing
* [http://meta.wikimedia.org/wiki/Help:Formula MediaWiki Help:Formula]
* [http://meta.wikimedia.org/wiki/Help:Wikitext_examples Help:Wikitext Examples]

; Configuration
* [http://www.mediawiki.org/wiki/Manual:Configuration_settings Configuration settings list]

; Mediawiki General
* [http://www.mediawiki.org/wiki/Manual:FAQ MediaWiki FAQ]
* [http://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

; Questions
*[[User: Algowikiadmin| The Admin]] (editing fixes for the problems)
* [http://www.cs.sunysb.edu/~skiena/ Steven Skiena] (for additional hints and algorithm magic)</text>
      <sha1>9jk7f64rmrhytrxlugojw7d34evyy15</sha1>
    </revision>
    <revision>
      <id>443</id>
      <parentid>442</parentid>
      <timestamp>2020-10-01T18:01:33Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>/* Chapters */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1851">The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with the third edition of Steven Skiena's ''The Algorithm Design Manual''. Students and other readers are encouraged to contribute hints and answers to all odd-numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.


&lt;big&gt;Chapters&lt;/big&gt;

#[[Chapter 1|Introduction to Algorithms]]
#[[Chapter 2|Algorithm Analysis]]
#[[Chapter 3|Data Structures]]
#[[Chapter 4|Sorting]]
#[[Chapter 5|Divide and Conquer]]
#[[Chapter 6|Hashing and Randomized Algorithms]]
#[[Chapter 7|Graph Traversal]]
#[[Chapter 8|Weighted Graph Algorithms]]
#[[Chapter 9|Combinatorial Search]]
#[[Chapter 10|Dynamic Programming]]
#[[Chapter 11|NP-Completeness]]
#[[Chapter 12|Dealing with Hard Problems]]

== Getting started ==
; Editing
* [http://meta.wikimedia.org/wiki/Help:Formula MediaWiki Help:Formula]
* [http://meta.wikimedia.org/wiki/Help:Wikitext_examples Help:Wikitext Examples]

; Configuration
* [http://www.mediawiki.org/wiki/Manual:Configuration_settings Configuration settings list]

; Mediawiki General
* [http://www.mediawiki.org/wiki/Manual:FAQ MediaWiki FAQ]
* [http://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

; Questions
*[[User: Algowikiadmin| The Admin]] (editing fixes for the problems)
* [http://www.cs.sunysb.edu/~skiena/ Steven Skiena] (for additional hints and algorithm magic)</text>
      <sha1>lss7oogjsfp78ph5f9s5e3nn8c86qkz</sha1>
    </revision>
    <revision>
      <id>444</id>
      <parentid>443</parentid>
      <timestamp>2020-10-01T18:01:44Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1850">The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with the third edition of Steven Skiena's ''The Algorithm Design Manual''. Students and other readers are encouraged to contribute hints and answers to all odd-numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.

&lt;big&gt;Chapters&lt;/big&gt;

#[[Chapter 1|Introduction to Algorithms]]
#[[Chapter 2|Algorithm Analysis]]
#[[Chapter 3|Data Structures]]
#[[Chapter 4|Sorting]]
#[[Chapter 5|Divide and Conquer]]
#[[Chapter 6|Hashing and Randomized Algorithms]]
#[[Chapter 7|Graph Traversal]]
#[[Chapter 8|Weighted Graph Algorithms]]
#[[Chapter 9|Combinatorial Search]]
#[[Chapter 10|Dynamic Programming]]
#[[Chapter 11|NP-Completeness]]
#[[Chapter 12|Dealing with Hard Problems]]

== Getting started ==
; Editing
* [http://meta.wikimedia.org/wiki/Help:Formula MediaWiki Help:Formula]
* [http://meta.wikimedia.org/wiki/Help:Wikitext_examples Help:Wikitext Examples]

; Configuration
* [http://www.mediawiki.org/wiki/Manual:Configuration_settings Configuration settings list]

; Mediawiki General
* [http://www.mediawiki.org/wiki/Manual:FAQ MediaWiki FAQ]
* [http://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

; Questions
*[[User: Algowikiadmin| The Admin]] (editing fixes for the problems)
* [http://www.cs.sunysb.edu/~skiena/ Steven Skiena] (for additional hints and algorithm magic)</text>
      <sha1>4pcbx9ra85jczyudach3pebpsih5cyg</sha1>
    </revision>
    <revision>
      <id>445</id>
      <parentid>444</parentid>
      <timestamp>2020-10-01T18:05:31Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <minor/>
      <comment>Protected "[[Main Page]]" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1850">The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with the third edition of Steven Skiena's ''The Algorithm Design Manual''. Students and other readers are encouraged to contribute hints and answers to all odd-numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.

&lt;big&gt;Chapters&lt;/big&gt;

#[[Chapter 1|Introduction to Algorithms]]
#[[Chapter 2|Algorithm Analysis]]
#[[Chapter 3|Data Structures]]
#[[Chapter 4|Sorting]]
#[[Chapter 5|Divide and Conquer]]
#[[Chapter 6|Hashing and Randomized Algorithms]]
#[[Chapter 7|Graph Traversal]]
#[[Chapter 8|Weighted Graph Algorithms]]
#[[Chapter 9|Combinatorial Search]]
#[[Chapter 10|Dynamic Programming]]
#[[Chapter 11|NP-Completeness]]
#[[Chapter 12|Dealing with Hard Problems]]

== Getting started ==
; Editing
* [http://meta.wikimedia.org/wiki/Help:Formula MediaWiki Help:Formula]
* [http://meta.wikimedia.org/wiki/Help:Wikitext_examples Help:Wikitext Examples]

; Configuration
* [http://www.mediawiki.org/wiki/Manual:Configuration_settings Configuration settings list]

; Mediawiki General
* [http://www.mediawiki.org/wiki/Manual:FAQ MediaWiki FAQ]
* [http://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

; Questions
*[[User: Algowikiadmin| The Admin]] (editing fixes for the problems)
* [http://www.cs.sunysb.edu/~skiena/ Steven Skiena] (for additional hints and algorithm magic)</text>
      <sha1>4pcbx9ra85jczyudach3pebpsih5cyg</sha1>
    </revision>
    <revision>
      <id>460</id>
      <parentid>445</parentid>
      <timestamp>2020-10-26T14:35:55Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Redirected page to [[Solution Wiki, TheAlgorithm Design Manual, 3rd Edition"]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1921">#REDIRECT [[Solution Wiki, TheAlgorithm Design Manual, 3rd Edition"]]

The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with the third edition of Steven Skiena's ''The Algorithm Design Manual''. Students and other readers are encouraged to contribute hints and answers to all odd-numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.

&lt;big&gt;Chapters&lt;/big&gt;

#[[Chapter 1|Introduction to Algorithms]]
#[[Chapter 2|Algorithm Analysis]]
#[[Chapter 3|Data Structures]]
#[[Chapter 4|Sorting]]
#[[Chapter 5|Divide and Conquer]]
#[[Chapter 6|Hashing and Randomized Algorithms]]
#[[Chapter 7|Graph Traversal]]
#[[Chapter 8|Weighted Graph Algorithms]]
#[[Chapter 9|Combinatorial Search]]
#[[Chapter 10|Dynamic Programming]]
#[[Chapter 11|NP-Completeness]]
#[[Chapter 12|Dealing with Hard Problems]]

== Getting started ==
; Editing
* [http://meta.wikimedia.org/wiki/Help:Formula MediaWiki Help:Formula]
* [http://meta.wikimedia.org/wiki/Help:Wikitext_examples Help:Wikitext Examples]

; Configuration
* [http://www.mediawiki.org/wiki/Manual:Configuration_settings Configuration settings list]

; Mediawiki General
* [http://www.mediawiki.org/wiki/Manual:FAQ MediaWiki FAQ]
* [http://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

; Questions
*[[User: Algowikiadmin| The Admin]] (editing fixes for the problems)
* [http://www.cs.sunysb.edu/~skiena/ Steven Skiena] (for additional hints and algorithm magic)</text>
      <sha1>fwa2r0ipcwu9lufl1xvadpk5t77k5th</sha1>
    </revision>
    <revision>
      <id>462</id>
      <parentid>460</parentid>
      <timestamp>2020-10-26T14:37:22Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Changed redirect target from [[Solution Wiki, TheAlgorithm Design Manual, 3rd Edition"]] to [[Solution Wiki, TheAlgorithm Design Manual, 3rd Edition]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1920">#REDIRECT [[Solution Wiki, TheAlgorithm Design Manual, 3rd Edition]]

The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with the third edition of Steven Skiena's ''The Algorithm Design Manual''. Students and other readers are encouraged to contribute hints and answers to all odd-numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.

&lt;big&gt;Chapters&lt;/big&gt;

#[[Chapter 1|Introduction to Algorithms]]
#[[Chapter 2|Algorithm Analysis]]
#[[Chapter 3|Data Structures]]
#[[Chapter 4|Sorting]]
#[[Chapter 5|Divide and Conquer]]
#[[Chapter 6|Hashing and Randomized Algorithms]]
#[[Chapter 7|Graph Traversal]]
#[[Chapter 8|Weighted Graph Algorithms]]
#[[Chapter 9|Combinatorial Search]]
#[[Chapter 10|Dynamic Programming]]
#[[Chapter 11|NP-Completeness]]
#[[Chapter 12|Dealing with Hard Problems]]

== Getting started ==
; Editing
* [http://meta.wikimedia.org/wiki/Help:Formula MediaWiki Help:Formula]
* [http://meta.wikimedia.org/wiki/Help:Wikitext_examples Help:Wikitext Examples]

; Configuration
* [http://www.mediawiki.org/wiki/Manual:Configuration_settings Configuration settings list]

; Mediawiki General
* [http://www.mediawiki.org/wiki/Manual:FAQ MediaWiki FAQ]
* [http://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

; Questions
*[[User: Algowikiadmin| The Admin]] (editing fixes for the problems)
* [http://www.cs.sunysb.edu/~skiena/ Steven Skiena] (for additional hints and algorithm magic)</text>
      <sha1>46i3m0hbc5jaza04ajzjffu1nserf02</sha1>
    </revision>
    <revision>
      <id>464</id>
      <parentid>462</parentid>
      <timestamp>2020-10-28T18:09:06Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Changed redirect target from [[Solution Wiki, TheAlgorithm Design Manual, 3rd Edition]] to [[Solution Wiki, The Algorithm Design Manual, 3rd Edition]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1921">#REDIRECT [[Solution Wiki, The Algorithm Design Manual, 3rd Edition]]

The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with the third edition of Steven Skiena's ''The Algorithm Design Manual''. Students and other readers are encouraged to contribute hints and answers to all odd-numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.

&lt;big&gt;Chapters&lt;/big&gt;

#[[Chapter 1|Introduction to Algorithms]]
#[[Chapter 2|Algorithm Analysis]]
#[[Chapter 3|Data Structures]]
#[[Chapter 4|Sorting]]
#[[Chapter 5|Divide and Conquer]]
#[[Chapter 6|Hashing and Randomized Algorithms]]
#[[Chapter 7|Graph Traversal]]
#[[Chapter 8|Weighted Graph Algorithms]]
#[[Chapter 9|Combinatorial Search]]
#[[Chapter 10|Dynamic Programming]]
#[[Chapter 11|NP-Completeness]]
#[[Chapter 12|Dealing with Hard Problems]]

== Getting started ==
; Editing
* [http://meta.wikimedia.org/wiki/Help:Formula MediaWiki Help:Formula]
* [http://meta.wikimedia.org/wiki/Help:Wikitext_examples Help:Wikitext Examples]

; Configuration
* [http://www.mediawiki.org/wiki/Manual:Configuration_settings Configuration settings list]

; Mediawiki General
* [http://www.mediawiki.org/wiki/Manual:FAQ MediaWiki FAQ]
* [http://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

; Questions
*[[User: Algowikiadmin| The Admin]] (editing fixes for the problems)
* [http://www.cs.sunysb.edu/~skiena/ Steven Skiena] (for additional hints and algorithm magic)</text>
      <sha1>i1i10hg6u2lssax17tngyk7vxyb6ea4</sha1>
    </revision>
  </page>
  <page>
    <title>Problem Solutions</title>
    <ns>0</ns>
    <id>5</id>
    <redirect title="Chapter List" />
    <revision>
      <id>10</id>
      <timestamp>2020-08-23T19:30:09Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Algowikiadmin moved page [[Problem Solutions]] to [[Chapter List]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="26">#REDIRECT [[Chapter List]]</text>
      <sha1>d5al9hc12qbt3druf00wmbgbm7nt2pp</sha1>
    </revision>
  </page>
  <page>
    <title>Solution Wiki, The Algorithm Design Manual, 3rd Edition</title>
    <ns>0</ns>
    <id>235</id>
    <revision>
      <id>465</id>
      <timestamp>2020-10-28T18:09:13Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with " The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with the third edition of Steven Skiena's ''The Algorithm Design Manual''. Students..."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1851">
The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with the third edition of Steven Skiena's ''The Algorithm Design Manual''. Students and other readers are encouraged to contribute hints and answers to all odd-numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.

&lt;big&gt;Chapters&lt;/big&gt;

#[[Chapter 1|Introduction to Algorithms]]
#[[Chapter 2|Algorithm Analysis]]
#[[Chapter 3|Data Structures]]
#[[Chapter 4|Sorting]]
#[[Chapter 5|Divide and Conquer]]
#[[Chapter 6|Hashing and Randomized Algorithms]]
#[[Chapter 7|Graph Traversal]]
#[[Chapter 8|Weighted Graph Algorithms]]
#[[Chapter 9|Combinatorial Search]]
#[[Chapter 10|Dynamic Programming]]
#[[Chapter 11|NP-Completeness]]
#[[Chapter 12|Dealing with Hard Problems]]

== Getting started ==
; Editing
* [http://meta.wikimedia.org/wiki/Help:Formula MediaWiki Help:Formula]
* [http://meta.wikimedia.org/wiki/Help:Wikitext_examples Help:Wikitext Examples]

; Configuration
* [http://www.mediawiki.org/wiki/Manual:Configuration_settings Configuration settings list]

; Mediawiki General
* [http://www.mediawiki.org/wiki/Manual:FAQ MediaWiki FAQ]
* [http://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

; Questions
*[[User: Algowikiadmin| The Admin]] (editing fixes for the problems)
* [http://www.cs.sunysb.edu/~skiena/ Steven Skiena] (for additional hints and algorithm magic)</text>
      <sha1>tef3pqtdl5hul41r77iejqdk39f0mmb</sha1>
    </revision>
    <revision>
      <id>466</id>
      <parentid>465</parentid>
      <timestamp>2020-10-28T18:14:21Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1932">
The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with the third edition of Steven Skiena's ''The Algorithm Design Manual''. Students and other readers are encouraged to contribute hints and answers to all odd-numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.

&lt;big&gt;Chapters&lt;/big&gt;

#[[Chapter 1|Introduction to Algorithms]]
#[[Chapter 2|Algorithm Analysis]]
#[[Chapter 3|Data Structures]]
#[[Chapter 4|Sorting]]
#[[Chapter 5|Divide and Conquer]]
#[[Chapter 6|Hashing and Randomized Algorithms]]
#[[Chapter 7|Graph Traversal]]
#[[Chapter 8|Weighted Graph Algorithms]]
#[[Chapter 9|Combinatorial Search]]
#[[Chapter 10|Dynamic Programming]]
#[[Chapter 11|NP-Completeness]]
#[[Chapter 12|Dealing with Hard Problems]]


The second edition of the solution wiki can be found [[Second Edition|here]].


== Getting started ==
; Editing
* [http://meta.wikimedia.org/wiki/Help:Formula MediaWiki Help:Formula]
* [http://meta.wikimedia.org/wiki/Help:Wikitext_examples Help:Wikitext Examples]

; Configuration
* [http://www.mediawiki.org/wiki/Manual:Configuration_settings Configuration settings list]

; Mediawiki General
* [http://www.mediawiki.org/wiki/Manual:FAQ MediaWiki FAQ]
* [http://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

; Questions
*[[User: Algowikiadmin| The Admin]] (editing fixes for the problems)
* [http://www.cs.sunysb.edu/~skiena/ Steven Skiena] (for additional hints and algorithm magic)</text>
      <sha1>gpybz9m9koj8x3j26aefnq8e8aoyjii</sha1>
    </revision>
    <revision>
      <id>467</id>
      <parentid>466</parentid>
      <timestamp>2020-10-28T18:14:32Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="1931">
The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with the third edition of Steven Skiena's ''The Algorithm Design Manual''. Students and other readers are encouraged to contribute hints and answers to all odd-numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.

&lt;big&gt;Chapters&lt;/big&gt;

#[[Chapter 1|Introduction to Algorithms]]
#[[Chapter 2|Algorithm Analysis]]
#[[Chapter 3|Data Structures]]
#[[Chapter 4|Sorting]]
#[[Chapter 5|Divide and Conquer]]
#[[Chapter 6|Hashing and Randomized Algorithms]]
#[[Chapter 7|Graph Traversal]]
#[[Chapter 8|Weighted Graph Algorithms]]
#[[Chapter 9|Combinatorial Search]]
#[[Chapter 10|Dynamic Programming]]
#[[Chapter 11|NP-Completeness]]
#[[Chapter 12|Dealing with Hard Problems]]


The second edition of the solution wiki can be found [[Second Edition|here]].

== Getting started ==
; Editing
* [http://meta.wikimedia.org/wiki/Help:Formula MediaWiki Help:Formula]
* [http://meta.wikimedia.org/wiki/Help:Wikitext_examples Help:Wikitext Examples]

; Configuration
* [http://www.mediawiki.org/wiki/Manual:Configuration_settings Configuration settings list]

; Mediawiki General
* [http://www.mediawiki.org/wiki/Manual:FAQ MediaWiki FAQ]
* [http://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

; Questions
*[[User: Algowikiadmin| The Admin]] (editing fixes for the problems)
* [http://www.cs.sunysb.edu/~skiena/ Steven Skiena] (for additional hints and algorithm magic)</text>
      <sha1>epdtkankol5z40vfmhfzkj5sg0gy2jb</sha1>
    </revision>
    <revision>
      <id>468</id>
      <parentid>467</parentid>
      <timestamp>2020-11-09T16:39:54Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="2007">
The Wiki is an experiment, a grass-roots effort to create an answer key to aid self-study with the third edition of Steven Skiena's ''The Algorithm Design Manual''. Students and other readers are encouraged to contribute hints and answers to all odd-numbered problems in the book, or expand/improve the solution contributed by others.

Please do not use this resource to cheat on your class homework. Recognize that no authority certifies the correctness of these solutions; they could well have been submitted by the idiot who sits in the back row of your class. Also recognize that other students in your class have equal access to these solutions, and it is typically easy for professors to recognize when two students submit the same solution.

&lt;big&gt;Chapters&lt;/big&gt;

#[[Chapter 1|Introduction to Algorithms]]
#[[Chapter 2|Algorithm Analysis]]
#[[Chapter 3|Data Structures]]
#[[Chapter 4|Sorting]]
#[[Chapter 5|Divide and Conquer]]
#[[Chapter 6|Hashing and Randomized Algorithms]]
#[[Chapter 7|Graph Traversal]]
#[[Chapter 8|Weighted Graph Algorithms]]
#[[Chapter 9|Combinatorial Search]]
#[[Chapter 10|Dynamic Programming]]
#[[Chapter 11|NP-Completeness]]
#[[Chapter 12|Dealing with Hard Problems]]


The second edition of the solution wiki can be found [https://www.algorist.com/algowiki_v2/index.php/The_Algorithms_Design_Manual_(Second_Edition) here].

== Getting started ==
; Editing
* [http://meta.wikimedia.org/wiki/Help:Formula MediaWiki Help:Formula]
* [http://meta.wikimedia.org/wiki/Help:Wikitext_examples Help:Wikitext Examples]

; Configuration
* [http://www.mediawiki.org/wiki/Manual:Configuration_settings Configuration settings list]

; Mediawiki General
* [http://www.mediawiki.org/wiki/Manual:FAQ MediaWiki FAQ]
* [http://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

; Questions
*[[User: Algowikiadmin| The Admin]] (editing fixes for the problems)
* [http://www.cs.sunysb.edu/~skiena/ Steven Skiena] (for additional hints and algorithm magic)</text>
      <sha1>tae21b6w5u59cfaz6j8wxo9kawxaz8n</sha1>
    </revision>
  </page>
  <page>
    <title>User:Algowikiadmin</title>
    <ns>2</ns>
    <id>232</id>
    <revision>
      <id>437</id>
      <timestamp>2020-09-28T17:32:43Z</timestamp>
      <contributor>
        <username>Algowikiadmin</username>
        <id>1</id>
      </contributor>
      <comment>Created page with "This admin account belongs to those that created and moderate this Wiki."</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text xml:space="preserve" bytes="72">This admin account belongs to those that created and moderate this Wiki.</text>
      <sha1>onpkv2vtnqkdl765imfhlyg66hi6e2w</sha1>
    </revision>
  </page>
</mediawiki>